fix: lazy-load genre/playlist views and cap playlist search scrolling

- Defer eager-load scrollbar checks to next event loop iteration via QTimer::singleShot(0), fixing initial load not filling the viewport - Playlist search: eagerly fill viewport, then show "Load more playlists…" button instead of infinite scroll to avoid loading thousands of results - Increase search page size from 8 to 25 - Featured/discover playlists keep auto-scroll behavior unchanged Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Merge branch 'refactor/code-quality'
2026-03-31 11:17:23 +02:00 · 2026-03-31 10:54:49 +02:00 · 2026-03-31 10:48:21 +02:00 · 2026-03-31 10:43:36 +02:00 · 2026-03-31 02:02:31 +02:00 · 2026-03-31 01:49:53 +02:00
47 changed files with 13518 additions and 708 deletions
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -0,0 +1,49 @@
+name: Build for Windows
+
+on:
+  push:
+    branches: [ "main", "feature/cross-platform" ]
+  pull_request:
+    branches: [ "main" ]
+  workflow_dispatch:
+
+jobs:
+  build-windows:
+    runs-on: windows-latest
+    
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Setup Rust toolchain
+      uses: dtolnay/rust-toolchain@stable
+      with:
+        toolchain: stable
+        target: x86_64-pc-windows-msvc
+
+    - name: Install Qt 6
+      uses: jurplel/install-qt-action@v4
+      with:
+        version: '6.5.3'
+        host: 'windows'
+        target: 'desktop'
+        arch: 'win64_msvc2019_64'
+
+    - name: Configure CMake
+      run: cmake -B build -S . -DCMAKE_BUILD_TYPE=Release
+
+    - name: Build Application
+      run: cmake --build build --config Release -j %NUMBER_OF_PROCESSORS%
+
+    - name: Bundle Executable (windeployqt)
+      run: |
+        mkdir release
+        copy build\Release\qobuz-qt.exe release\
+        windeployqt release\qobuz-qt.exe
+      shell: cmd
+
+    - name: Upload Artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: qobuz-qt-windows-x64
+        path: release/
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,7 @@
 build/
+build-*/
 target/
+src/visualizer/
 .cache/
 *.user
 *.autosave
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -38,7 +38,11 @@ else()
    set(CARGO_PROFILE_FLAG "")
 endif()

+if(WIN32 AND MSVC)
+    set(RUST_LIB "${CMAKE_SOURCE_DIR}/target/${CARGO_PROFILE}/qobuz_backend.lib")
+else()
    set(RUST_LIB "${CMAKE_SOURCE_DIR}/target/${CARGO_PROFILE}/libqobuz_backend.a")
+endif()

 add_custom_target(rust_backend ALL
    COMMAND ${CARGO_CMD} build ${CARGO_PROFILE_FLAG}
@@ -83,14 +87,39 @@ target_link_libraries(qobuz-qt PRIVATE
    qobuz_backend_lib
 )

-# Platform-specific system libs needed by the Rust audio stack (cpal/ALSA)
+# Platform-specific system libs needed by the Rust audio stack (cpal/backend internals)
 if (UNIX AND NOT APPLE)
    target_link_libraries(qobuz-qt PRIVATE asound)
+elseif (APPLE)
+    find_library(COREAUDIO CoreAudio)
+    find_library(AUDIOTOOLBOX AudioToolbox)
+    find_library(SECURITY Security)
+    find_library(COREFOUNDATION CoreFoundation)
+    target_link_libraries(qobuz-qt PRIVATE ${COREAUDIO} ${AUDIOTOOLBOX} ${SECURITY} ${COREFOUNDATION})
+elseif (WIN32)
+    target_link_libraries(qobuz-qt PRIVATE ws2_32 userenv bcrypt advapi32 ntdll ole32)
 endif ()

-# Compiler warnings
+# Compiler warnings + hardening
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    target_compile_options(qobuz-qt PRIVATE -Wall -Wextra -Wno-unused-parameter)
+    target_compile_options(qobuz-qt PRIVATE
+        -Wall -Wextra -Wno-unused-parameter
+    )
+    if (UNIX AND NOT APPLE)
+        target_compile_options(qobuz-qt PRIVATE
+            -fstack-protector-strong
+            -fPIE
+            # _FORTIFY_SOURCE needs optimized builds; in Debug it causes warning spam.
+            $<$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>,$<CONFIG:MinSizeRel>>:-D_FORTIFY_SOURCE=2>
+            $<$<CONFIG:Debug>:-U_FORTIFY_SOURCE>
+        )
+        target_link_options(qobuz-qt PRIVATE
+            -pie
+            -Wl,-z,relro,-z,now
+        )
+    endif ()
+elseif (MSVC)
+    target_compile_options(qobuz-qt PRIVATE /W3 /Zc:__cplusplus /permissive-)
 endif ()

 # D-Bus
@@ -109,7 +138,7 @@ if (USE_LTO)
 endif ()

 # Install
-if (UNIX)
+if (UNIX AND NOT APPLE)
    install(FILES res/logo/qobuz-qt.svg DESTINATION share/icons/hicolor/scalable/apps)
    install(FILES res/app/qobuz-qt.desktop DESTINATION share/applications)
    install(TARGETS qobuz-qt RUNTIME DESTINATION bin)
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,17 @@
 # It is not intended for manual editing.
 version = 4

+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.4"
@@ -93,6 +104,24 @@ version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"

+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.20.2"
@@ -111,6 +140,15 @@ version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"

+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher",
+]
+
 [[package]]
 name = "cc"
 version = "1.2.57"
@@ -150,6 +188,16 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"

+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
 [[package]]
 name = "clang-sys"
 version = "1.8.1"
@@ -221,12 +269,51 @@ dependencies = [
 "windows",
 ]

+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "ctr"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
+dependencies = [
+ "cipher",
+]
+
 [[package]]
 name = "dasp_sample"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"

+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "subtle",
+]
+
 [[package]]
 name = "dirs"
 version = "5.0.1"
@@ -372,6 +459,16 @@ dependencies = [
 "slab",
 ]

+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.17"
@@ -411,6 +508,30 @@ version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"

+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hkdf"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
+dependencies = [
+ "hmac",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
 [[package]]
 name = "http"
 version = "1.4.0"
@@ -623,6 +744,16 @@ dependencies = [
 "hashbrown",
 ]

+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "block-padding",
+ "generic-array",
+]
+
 [[package]]
 name = "ipnet"
 version = "2.12.0"
@@ -1054,14 +1185,21 @@ dependencies = [
 name = "qobuz-backend"
 version = "0.1.0"
 dependencies = [
+ "aes",
 "anyhow",
+ "base64",
+ "cbc",
 "cpal",
+ "ctr",
 "dirs",
+ "hex",
+ "hkdf",
 "md5",
 "rb",
 "reqwest",
 "serde",
 "serde_json",
+ "sha2",
 "symphonia",
 "thiserror 2.0.18",
 "tokio",
@@ -1410,6 +1548,17 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
 [[package]]
 name = "shlex"
 version = "1.3.0"
@@ -1943,6 +2092,12 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"

+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
@@ -1973,6 +2128,12 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"

+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"
--- a/openapi.json
+++ b/openapi.json
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -28,6 +28,16 @@ md5 = "0.7"
 dirs = "5"
 toml = "0.8"

+# Crypto — qbz-1 key derivation + segment decryption
+aes   = "0.8"
+cbc   = { version = "0.1", features = ["alloc"] }
+ctr   = "0.9"
+hkdf  = "0.12"
+sha2  = "0.10"
+hex   = "0.4"
+base64 = "0.22"
+
 [profile.release]
 lto = "thin"
 opt-level = 3
+overflow-checks = true
--- a/rust/include/qobuz_backend.h
+++ b/rust/include/qobuz_backend.h
@@ -34,6 +34,18 @@ enum QobuzEvent {
    EV_PLAYLIST_CREATED      = 20,
    EV_PLAYLIST_DELETED      = 21,
    EV_PLAYLIST_TRACK_ADDED  = 22,
+    EV_USER_OK               = 23,
+    EV_ARTIST_RELEASES_OK    = 24,
+    EV_DEEP_SHUFFLE_OK       = 25,
+    EV_MOST_POPULAR_OK       = 26,
+    EV_GENRES_OK             = 27,
+    EV_FEATURED_ALBUMS_OK    = 28,
+    EV_DYNAMIC_SUGGEST_OK    = 29,
+    EV_FEATURED_PLAYLISTS_OK = 30,
+    EV_DISCOVER_PLAYLISTS_OK = 31,
+    EV_PLAYLIST_SEARCH_OK    = 32,
+    EV_PLAYLIST_SUBSCRIBED   = 33,
+    EV_PLAYLIST_UNSUBSCRIBED = 34,
 };

 // Callback signature
@@ -46,12 +58,16 @@ void                qobuz_backend_free(QobuzBackendOpaque *backend);
 // Auth
 void qobuz_backend_login(QobuzBackendOpaque *backend, const char *email, const char *password);
 void qobuz_backend_set_token(QobuzBackendOpaque *backend, const char *token);
+void qobuz_backend_get_user(QobuzBackendOpaque *backend);

 // Catalog
 void qobuz_backend_search(QobuzBackendOpaque *backend, const char *query, uint32_t offset, uint32_t limit);
+void qobuz_backend_most_popular_search(QobuzBackendOpaque *backend, const char *query, uint32_t limit);
+void qobuz_backend_get_dynamic_suggestions(QobuzBackendOpaque *backend, const char *listened_track_ids_json, const char *tracks_to_analyze_json, uint32_t limit);
 void qobuz_backend_get_album(QobuzBackendOpaque *backend, const char *album_id);
 void qobuz_backend_get_artist(QobuzBackendOpaque *backend, int64_t artist_id);
 void qobuz_backend_get_playlist(QobuzBackendOpaque *backend, int64_t playlist_id, uint32_t offset, uint32_t limit);
+void qobuz_backend_get_playlist_all(QobuzBackendOpaque *backend, int64_t playlist_id);

 // Favorites
 void qobuz_backend_get_fav_tracks(QobuzBackendOpaque *backend, uint32_t offset, uint32_t limit);
@@ -71,23 +87,41 @@ uint64_t qobuz_backend_get_duration(const QobuzBackendOpaque *backend);
 uint8_t  qobuz_backend_get_volume(const QobuzBackendOpaque *backend);
 int      qobuz_backend_get_state(const QobuzBackendOpaque *backend);
 int      qobuz_backend_take_track_finished(QobuzBackendOpaque *backend);
+int      qobuz_backend_take_track_transitioned(QobuzBackendOpaque *backend);

 // ReplayGain / Gapless
 void qobuz_backend_set_replaygain(QobuzBackendOpaque *backend, bool enabled);
 void qobuz_backend_set_gapless(QobuzBackendOpaque *backend, bool enabled);
 void qobuz_backend_prefetch_track(QobuzBackendOpaque *backend, int64_t track_id, int32_t format_id);

+// Artist releases (auto-paginates to fetch all)
+void qobuz_backend_get_artist_releases(QobuzBackendOpaque *backend, int64_t artist_id, const char *release_type, uint32_t limit, uint32_t offset);
+
+// Deep shuffle: fetch tracks from multiple albums (album_ids_json is a JSON array of strings)
+void qobuz_backend_get_albums_tracks(QobuzBackendOpaque *backend, const char *album_ids_json);
+
+// Browse
+void qobuz_backend_get_genres(QobuzBackendOpaque *backend);
+void qobuz_backend_get_featured_albums(QobuzBackendOpaque *backend, const char *genre_ids, const char *kind, uint32_t limit, uint32_t offset);
+void qobuz_backend_get_featured_playlists(QobuzBackendOpaque *backend, const char *genre_ids, const char *kind, uint32_t limit, uint32_t offset);
+void qobuz_backend_discover_playlists(QobuzBackendOpaque *backend, const char *genre_ids, const char *tags, uint32_t limit, uint32_t offset);
+void qobuz_backend_search_playlists(QobuzBackendOpaque *backend, const char *query, uint32_t limit, uint32_t offset);
+
 // Playlist management
 void qobuz_backend_create_playlist(QobuzBackendOpaque *backend, const char *name);
 void qobuz_backend_delete_playlist(QobuzBackendOpaque *backend, int64_t playlist_id);
 void qobuz_backend_add_track_to_playlist(QobuzBackendOpaque *backend, int64_t playlist_id, int64_t track_id);
 void qobuz_backend_delete_track_from_playlist(QobuzBackendOpaque *backend, int64_t playlist_id, int64_t playlist_track_id);
+void qobuz_backend_subscribe_playlist(QobuzBackendOpaque *backend, int64_t playlist_id);
+void qobuz_backend_unsubscribe_playlist(QobuzBackendOpaque *backend, int64_t playlist_id);

 // Favorites modification
 void qobuz_backend_add_fav_track(QobuzBackendOpaque *backend, int64_t track_id);
 void qobuz_backend_remove_fav_track(QobuzBackendOpaque *backend, int64_t track_id);
 void qobuz_backend_add_fav_album(QobuzBackendOpaque *backend, const char *album_id);
 void qobuz_backend_remove_fav_album(QobuzBackendOpaque *backend, const char *album_id);
+void qobuz_backend_add_fav_artist(QobuzBackendOpaque *backend, int64_t artist_id);
+void qobuz_backend_remove_fav_artist(QobuzBackendOpaque *backend, int64_t artist_id);

 #ifdef __cplusplus
 }
--- a/rust/src/api/client.rs
+++ b/rust/src/api/client.rs
@@ -1,6 +1,10 @@
 use anyhow::{bail, Result};
+use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
+use cbc::cipher::{block_padding::NoPadding, BlockDecryptMut, KeyIvInit};
+use hkdf::Hkdf;
 use reqwest::Client;
 use serde_json::Value;
+use sha2::Sha256;
 use std::time::{SystemTime, UNIX_EPOCH};

 use super::models::*;
@@ -15,10 +19,74 @@ pub const DEFAULT_APP_SECRET: &str = "e79f8b9be485692b0e5f9dd895826368";
 pub struct QobuzClient {
    http: Client,
    pub auth_token: Option<String>,
+    /// Playback session ID from POST /session/start — sent as X-Session-Id for /file/url.
+    session_id: Option<String>,
+    session_expires_at: Option<u64>,
+    /// `infos` field from the session/start response — used to derive the KEK for track key unwrapping.
+    session_infos: Option<String>,
    app_id: String,
    app_secret: String,
 }

+// ── qbz-1 key derivation helpers ─────────────────────────────────────────────
+
+type Aes128CbcDec = cbc::Decryptor<aes::Aes128>;
+
+/// Decode a base64url string (with or without padding).
+fn b64url_decode(s: &str) -> Result<Vec<u8>> {
+    Ok(URL_SAFE_NO_PAD.decode(s.trim_end_matches('='))?)
+}
+
+/// Full qbz-1 key derivation:
+///   Phase 1: HKDF-SHA256(ikm=hex(app_secret), salt=b64url(infos[0]), info=b64url(infos[1])) → 16-byte KEK
+///   Phase 2: AES-128-CBC/NoPadding(key=KEK, iv=b64url(key_field[2])).decrypt(b64url(key_field[1]))[..16]
+fn derive_track_key(
+    session_infos: &str,
+    app_secret_hex: &str,
+    key_field: &str,
+) -> Result<[u8; 16]> {
+    // Phase 1: HKDF
+    let infos_parts: Vec<&str> = session_infos.splitn(2, '.').collect();
+    if infos_parts.len() != 2 {
+        bail!("session_infos must be '<salt_b64>.<info_b64>', got: {session_infos}");
+    }
+    let salt = b64url_decode(infos_parts[0])?;
+    let info = b64url_decode(infos_parts[1])?;
+    let ikm = hex::decode(app_secret_hex)?;
+
+    let hk = Hkdf::<Sha256>::new(Some(&salt), &ikm);
+    let mut kek = [0u8; 16];
+    hk.expand(&info, &mut kek)
+        .map_err(|e| anyhow::anyhow!("HKDF expand failed: {e:?}"))?;
+
+    // Phase 2: AES-128-CBC/NoPadding
+    let key_parts: Vec<&str> = key_field.splitn(3, '.').collect();
+    if key_parts.len() != 3 || key_parts[0] != "qbz-1" {
+        bail!("unexpected key field format: {key_field}");
+    }
+    let ct = b64url_decode(key_parts[1])?;
+    let iv_bytes = b64url_decode(key_parts[2])?;
+    if ct.len() < 16 || iv_bytes.len() < 16 {
+        bail!(
+            "key field ciphertext/iv too short ({} / {} bytes)",
+            ct.len(),
+            iv_bytes.len()
+        );
+    }
+
+    let iv: [u8; 16] = iv_bytes[..16].try_into()?;
+    let mut buf = ct;
+    let decrypted = Aes128CbcDec::new(&kek.into(), &iv.into())
+        .decrypt_padded_mut::<NoPadding>(&mut buf)
+        .map_err(|e| anyhow::anyhow!("AES-CBC decrypt failed: {e:?}"))?;
+
+    let mut track_key = [0u8; 16];
+    track_key.copy_from_slice(&decrypted[..16]);
+    Ok(track_key)
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
 impl QobuzClient {
    pub fn new() -> Result<Self> {
        Self::new_with_config(None, None)
@@ -44,6 +112,9 @@ impl QobuzClient {
        Ok(Self {
            http,
            auth_token: None,
+            session_id: None,
+            session_expires_at: None,
+            session_infos: None,
            app_id,
            app_secret,
        })
@@ -60,6 +131,8 @@ impl QobuzClient {
            .as_secs()
    }

+    /// Compute the request signature required by the Qobuz API.
+    /// NOTE: MD5 is mandated by the Qobuz API protocol — not our choice.
    fn request_sig(&self, method: &str, params: &mut Vec<(&str, String)>, ts: u64) -> String {
        params.sort_by_key(|(k, _)| *k);
        let mut s = method.replace('/', "");
@@ -104,19 +177,16 @@ impl QobuzClient {
        if let Some(token) = &self.auth_token {
            builder = builder.header("Authorization", format!("Bearer {}", token));
        }
+        if let Some(sid) = &self.session_id {
+            builder = builder.header("X-Session-Id", sid.as_str());
+        }
        builder
    }

    // --- Auth ---

+    /// NOTE: Qobuz API requires credentials as GET query params — not our choice.
    pub async fn login(&mut self, email: &str, password: &str) -> Result<OAuthLoginResponse> {
-        match self.oauth2_login(email, password).await {
-            Ok(r) => Ok(r),
-            Err(_) => self.legacy_login(email, password).await,
-        }
-    }
-
-    async fn oauth2_login(&mut self, email: &str, password: &str) -> Result<OAuthLoginResponse> {
        let ts = Self::ts();
        let mut sign_params: Vec<(&str, String)> = vec![
            ("password", password.to_string()),
@@ -140,45 +210,18 @@ impl QobuzClient {
        let status = resp.status();
        let body: Value = resp.json().await?;
        if !status.is_success() {
-            let msg = body.get("message").and_then(|m| m.as_str()).unwrap_or("login failed");
-            bail!("oauth2 login failed ({}): {}", status, msg);
-        }
-
-        self.extract_and_store_token(serde_json::from_value(body)?)
-    }
-
-    async fn legacy_login(&mut self, email: &str, password: &str) -> Result<OAuthLoginResponse> {
-        let ts = Self::ts();
-        let mut sign_params: Vec<(&str, String)> = vec![
-            ("email", email.to_string()),
-            ("password", password.to_string()),
-        ];
-        let sig = self.request_sig("userlogin", &mut sign_params, ts);
-
-        let resp = self
-            .http
-            .get(self.url("user/login"))
-            .query(&[
-                ("app_id", self.app_id.as_str()),
-                ("email", email),
-                ("password", password),
-                ("request_ts", ts.to_string().as_str()),
-                ("request_sig", sig.as_str()),
-            ])
-            .send()
-            .await?;
-
-        let status = resp.status();
-        let body: Value = resp.json().await?;
-        if !status.is_success() {
-            let msg = body.get("message").and_then(|m| m.as_str()).unwrap_or("login failed");
-            bail!("user login failed ({}): {}", status, msg);
+            let msg = body
+                .get("message")
+                .and_then(|m| m.as_str())
+                .unwrap_or("login failed");
+            bail!("login failed ({}): {}", status, msg);
        }

        self.extract_and_store_token(serde_json::from_value(body)?)
    }

    fn extract_and_store_token(&mut self, login: OAuthLoginResponse) -> Result<OAuthLoginResponse> {
+        // auth_token = OAuth2 bearer (preferred) or legacy session token
        if let Some(token) = login
            .oauth2
            .as_ref()
@@ -187,9 +230,63 @@ impl QobuzClient {
        {
            self.auth_token = Some(token);
        }
+        // Reset any cached playback session — it belongs to a different auth context.
+        self.session_id = None;
+        self.session_expires_at = None;
+        self.session_infos = None;
        Ok(login)
    }

+    /// Start a playback session via POST /session/start.
+    /// The returned session_id is required as X-Session-Id when calling /file/url.
+    /// Sessions expire; we cache and reuse until 60s before expiry.
+    async fn ensure_session(&mut self) -> Result<()> {
+        let now = Self::ts();
+        if let (Some(_), Some(exp)) = (&self.session_id, self.session_expires_at) {
+            if now + 60 < exp {
+                return Ok(()); // still valid
+            }
+        }
+
+        let ts = Self::ts();
+        let mut sign_params: Vec<(&str, String)> = vec![("profile", "qbz-1".to_string())];
+        let sig = self.request_sig("sessionstart", &mut sign_params, ts);
+
+        let resp = self
+            .http
+            .post(self.url("session/start"))
+            .query(&[
+                ("app_id", self.app_id.as_str()),
+                ("request_ts", ts.to_string().as_str()),
+                ("request_sig", sig.as_str()),
+            ])
+            .header(
+                "Authorization",
+                format!("Bearer {}", self.auth_token.as_deref().unwrap_or("")),
+            )
+            .form(&[("profile", "qbz-1")])
+            .send()
+            .await?;
+
+        let body = Self::check_response(resp).await?;
+        let session_id = body["session_id"]
+            .as_str()
+            .ok_or_else(|| anyhow::anyhow!("session/start: no session_id in response"))?
+            .to_string();
+        let expires_at = body["expires_at"].as_u64().unwrap_or(now + 3600);
+        let infos = body["infos"].as_str().map(|s| s.to_string());
+        eprintln!(
+            "[session] started session_id={}... expires_at={} infos={:?}",
+            &session_id[..session_id.len().min(8)],
+            expires_at,
+            infos
+        );
+        self.session_id = Some(session_id);
+        self.session_expires_at = Some(expires_at);
+        self.session_infos = infos;
+        Ok(())
+    }
+
    // --- User ---

    pub async fn get_user(&self) -> Result<UserDto> {
@@ -212,7 +309,13 @@ impl QobuzClient {
        Ok(serde_json::from_value(body)?)
    }

-    pub async fn get_track_url(&self, track_id: i64, format: Format) -> Result<TrackFileUrlDto> {
+    pub async fn get_track_url(
+        &mut self,
+        track_id: i64,
+        format: Format,
+    ) -> Result<TrackFileUrlDto> {
+        self.ensure_session().await?;
+
        let ts = Self::ts();
        let intent = "stream";
        let mut sign_params: Vec<(&str, String)> = vec![
@@ -220,10 +323,10 @@ impl QobuzClient {
            ("intent", intent.to_string()),
            ("track_id", track_id.to_string()),
        ];
-        let sig = self.request_sig("trackgetFileUrl", &mut sign_params, ts);
+        let sig = self.request_sig("fileurl", &mut sign_params, ts);

        let resp = self
-            .get_request("track/getFileUrl")
+            .get_request("file/url")
            .query(&[
                ("track_id", track_id.to_string()),
                ("format_id", format.id().to_string()),
@@ -235,7 +338,28 @@ impl QobuzClient {
            .await?;

        let body = Self::check_response(resp).await?;
-        Ok(serde_json::from_value(body)?)
+        eprintln!(
+            "[file/url] response: {}",
+            serde_json::to_string(&body).unwrap_or_default()
+        );
+        let mut url_dto: TrackFileUrlDto = serde_json::from_value(body)?;
+
+        // Unwrap the per-track key: decrypt the CBC-wrapped key using HKDF-derived KEK.
+        if let (Some(key_field), Some(infos)) = (url_dto.key.clone(), self.session_infos.as_deref())
+        {
+            match derive_track_key(infos, &self.app_secret, &key_field) {
+                Ok(track_key) => {
+                    url_dto.key = Some(hex::encode(track_key));
+                    eprintln!("[key] track key unwrapped OK");
+                }
+                Err(e) => {
+                    eprintln!("[key] track key unwrap failed: {e}");
+                    url_dto.key = None; // disable decryption rather than play garbage
+                }
+            }
+        }
+
+        Ok(url_dto)
    }

    // --- Album ---
@@ -252,24 +376,184 @@ impl QobuzClient {

    // --- Artist ---

-    pub async fn get_artist(&self, artist_id: i64) -> Result<ArtistDto> {
+    pub async fn get_artist_page(&self, artist_id: i64) -> Result<Value> {
        let resp = self
-            .get_request("artist/get")
+            .get_request("artist/page")
+            .query(&[("artist_id", artist_id.to_string())])
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
+    pub async fn get_artist_releases_list(
+        &self,
+        artist_id: i64,
+        release_type: &str,
+        limit: u32,
+        offset: u32,
+    ) -> Result<Value> {
+        let resp = self
+            .get_request("artist/getReleasesList")
            .query(&[
                ("artist_id", artist_id.to_string()),
-                ("extra", "albums".to_string()),
+                ("release_type", release_type.to_string()),
+                ("sort", "release_date".to_string()),
+                ("order", "desc".to_string()),
+                ("limit", limit.to_string()),
+                ("offset", offset.to_string()),
            ])
            .send()
            .await?;
-        let body = Self::check_response(resp).await?;
-        Ok(serde_json::from_value(body)?)
+        Self::check_response(resp).await
+    }
+
+    // --- Browse ---
+
+    pub async fn get_genres(&self) -> Result<Value> {
+        let resp = self.get_request("genre/list").send().await?;
+        Self::check_response(resp).await
+    }
+
+    pub async fn get_featured_albums(
+        &self,
+        genre_ids: &str,
+        kind: &str,
+        limit: u32,
+        offset: u32,
+    ) -> Result<Value> {
+        let resp = self
+            .get_request("album/getFeatured")
+            .query(&[
+                ("type", kind.to_string()),
+                ("genre_id", genre_ids.to_string()),
+                ("limit", limit.to_string()),
+                ("offset", offset.to_string()),
+            ])
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
+    pub async fn get_featured_playlists(
+        &self,
+        genre_ids: &str,
+        kind: &str,
+        limit: u32,
+        offset: u32,
+    ) -> Result<Value> {
+        let resp = self
+            .get_request("playlist/getFeatured")
+            .query(&[
+                ("type", kind.to_string()),
+                ("genre_ids", genre_ids.to_string()),
+                ("limit", limit.to_string()),
+                ("offset", offset.to_string()),
+            ])
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
+    pub async fn discover_playlists(
+        &self,
+        genre_ids: &str,
+        tags: &str,
+        limit: u32,
+        offset: u32,
+    ) -> Result<Value> {
+        let mut query = vec![
+            ("genre_ids", genre_ids.to_string()),
+            ("limit", limit.to_string()),
+            ("offset", offset.to_string()),
+        ];
+        if !tags.is_empty() {
+            query.push(("tags", tags.to_string()));
+        }
+
+        let resp = self
+            .get_request("discover/playlists")
+            .query(&query)
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
+    pub async fn search_playlists(&self, query: &str, limit: u32, offset: u32) -> Result<Value> {
+        let resp = self
+            .get_request("playlist/search")
+            .query(&[
+                ("query", query.to_string()),
+                ("limit", limit.to_string()),
+                ("offset", offset.to_string()),
+            ])
+            .send()
+            .await?;
+        Self::check_response(resp).await
    }

    // --- Search ---

    pub async fn search(&self, query: &str, offset: u32, limit: u32) -> Result<SearchCatalogDto> {
+        let (tracks_res, albums_res, artists_res) = tokio::join!(
+            self.search_tracks(query, offset, limit),
+            self.search_albums(query, offset, limit),
+            self.search_artists(query, offset, limit),
+        );
+
+        // Convert successful Results into Some(value) and Errors into None
+        Ok(SearchCatalogDto {
+            query: Some(query.to_string()),
+            tracks: tracks_res.ok(),
+            albums: albums_res.ok(),
+            artists: artists_res.ok(),
+            playlists: None,
+        })
+    }
+
+    pub async fn get_most_popular(
+        &self,
+        query: &str,
+        offset: u32,
+        limit: u32,
+    ) -> Result<Value> {
        let resp = self
-            .get_request("catalog/search")
+            .get_request("most-popular/get")
+            .query(&[
+                ("query", query.to_string()),
+                ("offset", offset.to_string()),
+                ("limit", limit.to_string()),
+            ])
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
+    pub async fn get_dynamic_suggestions(
+        &self,
+        limit: u32,
+        listened_tracks_ids: Value,
+        tracks_to_analyze: Value,
+    ) -> Result<Value> {
+        let resp = self
+            .post_request("dynamic/suggest")
+            .json(&serde_json::json!({
+                "limit": limit,
+                "listened_tracks_ids": listened_tracks_ids,
+                "track_to_analysed": tracks_to_analyze,
+            }))
+            .send()
+            .await?;
+        Self::check_response(resp).await
+    }
+
+    async fn search_tracks(
+        &self,
+        query: &str,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<TrackDto>> {
+        let resp = self
+            .get_request("track/search")
            .query(&[
                ("query", query),
                ("offset", &offset.to_string()),
@@ -278,22 +562,69 @@ impl QobuzClient {
            .send()
            .await?;
        let body = Self::check_response(resp).await?;
+        Ok(serde_json::from_value(body["tracks"].clone())?)
+    }
+
+    async fn search_albums(
+        &self,
+        query: &str,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<AlbumDto>> {
+        let resp = self
+            .get_request("album/search")
+            .query(&[
+                ("query", query),
+                ("offset", &offset.to_string()),
+                ("limit", &limit.to_string()),
+            ])
+            .send()
+            .await?;
+        let body = Self::check_response(resp).await?;
+        Ok(serde_json::from_value(body["albums"].clone())?)
+    }
+
+    async fn search_artists(
+        &self,
+        query: &str,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<ArtistDto>> {
+        let resp = self
+            .get_request("artist/search")
+            .query(&[
+                ("query", query),
+                ("offset", &offset.to_string()),
+                ("limit", &limit.to_string()),
+            ])
+            .send()
+            .await?;
+        let body = Self::check_response(resp).await?;
+        Ok(serde_json::from_value(body["artists"].clone())?)
+    }
+
+    // --- Favorites / Library ---
+
+    pub async fn get_user_playlists(&self, offset: u32, limit: u32) -> Result<UserPlaylistsDto> {
+        let resp = self
+            .get_request("playlist/getUserPlaylists")
+            .query(&[
+                ("filter", "owner,subscriber"),
+                ("offset", &offset.to_string()),
+                ("limit", &limit.to_string()),
+            ])
+            .send()
+            .await?;
+        let body = Self::check_response(resp).await?;
        Ok(serde_json::from_value(body)?)
    }

-    // --- Favorites / Library ---
-
-    pub async fn get_user_playlists(&self, offset: u32, limit: u32) -> Result<UserPlaylistsDto> {
-        let resp = self
-            .get_request("playlist/getUserPlaylists")
-            .query(&[("offset", &offset.to_string()), ("limit", &limit.to_string())])
-            .send()
-            .await?;
-        let body = Self::check_response(resp).await?;
-        Ok(serde_json::from_value(body)?)
-    }
-
-    pub async fn get_playlist(&self, playlist_id: i64, offset: u32, limit: u32) -> Result<PlaylistDto> {
+    pub async fn get_playlist(
+        &self,
+        playlist_id: i64,
+        offset: u32,
+        limit: u32,
+    ) -> Result<PlaylistDto> {
        let resp = self
            .get_request("playlist/get")
            .query(&[
@@ -308,34 +639,190 @@ impl QobuzClient {
        Ok(serde_json::from_value(body)?)
    }

-    pub async fn get_fav_tracks(&self, offset: u32, limit: u32) -> Result<SearchResultItems<TrackDto>> {
-        let resp = self
-            .get_request("favorite/getUserFavorites")
-            .query(&[("type", "tracks"), ("offset", &offset.to_string()), ("limit", &limit.to_string())])
-            .send()
-            .await?;
-        let body = Self::check_response(resp).await?;
-        Ok(serde_json::from_value(body["tracks"].clone())?)
+    pub async fn get_playlist_all(&self, playlist_id: i64) -> Result<PlaylistDto> {
+        const PAGE_LIMIT: u32 = 500;
+
+        let mut playlist = self.get_playlist(playlist_id, 0, PAGE_LIMIT).await?;
+
+        let mut all_items = playlist
+            .tracks
+            .as_ref()
+            .and_then(|t| t.items.clone())
+            .unwrap_or_default();
+
+        let mut total = playlist
+            .tracks
+            .as_ref()
+            .and_then(|t| t.total)
+            .unwrap_or(all_items.len() as i32);
+        if total < all_items.len() as i32 {
+            total = all_items.len() as i32;
        }

-    pub async fn get_fav_albums(&self, offset: u32, limit: u32) -> Result<SearchResultItems<AlbumDto>> {
-        let resp = self
-            .get_request("favorite/getUserFavorites")
-            .query(&[("type", "albums"), ("offset", &offset.to_string()), ("limit", &limit.to_string())])
-            .send()
-            .await?;
-        let body = Self::check_response(resp).await?;
-        Ok(serde_json::from_value(body["albums"].clone())?)
+        let mut offset = all_items.len() as u32;
+        while (offset as i32) < total {
+            let page = self.get_playlist(playlist_id, offset, PAGE_LIMIT).await?;
+            let mut page_items = page
+                .tracks
+                .as_ref()
+                .and_then(|t| t.items.clone())
+                .unwrap_or_default();
+            if page_items.is_empty() {
+                break;
+            }
+            all_items.append(&mut page_items);
+            offset = all_items.len() as u32;
        }

-    pub async fn get_fav_artists(&self, offset: u32, limit: u32) -> Result<SearchResultItems<FavArtistDto>> {
+        if let Some(tracks) = playlist.tracks.as_mut() {
+            tracks.items = Some(all_items);
+            tracks.total = Some(total);
+            tracks.offset = Some(0);
+            tracks.limit = Some(PAGE_LIMIT as i32);
+        }
+
+        Ok(playlist)
+    }
+
+    /// Fetch all favorite IDs (tracks, albums, artists) in one call.
+    async fn get_fav_ids(&self) -> Result<FavIdsDto> {
        let resp = self
-            .get_request("favorite/getUserFavorites")
-            .query(&[("type", "artists"), ("offset", &offset.to_string()), ("limit", &limit.to_string())])
+            .get_request("favorite/getUserFavoriteIds")
            .send()
            .await?;
        let body = Self::check_response(resp).await?;
-        Ok(serde_json::from_value(body["artists"].clone())?)
+        Ok(serde_json::from_value(body)?)
+    }
+
+    /// Batch-fetch tracks by ID via POST /track/getList.
+    async fn get_tracks_by_ids(&self, ids: &[i64]) -> Result<Vec<TrackDto>> {
+        if ids.is_empty() {
+            return Ok(vec![]);
+        }
+        let resp = self
+            .post_request("track/getList")
+            .json(&serde_json::json!({ "tracks_id": ids }))
+            .send()
+            .await?;
+        let body = Self::check_response(resp).await?;
+        let items: Vec<TrackDto> =
+            serde_json::from_value(body["tracks"]["items"].clone()).unwrap_or_default();
+        Ok(items)
+    }
+
+    pub async fn get_fav_tracks(
+        &self,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<TrackDto>> {
+        let ids = self.get_fav_ids().await?;
+        let all_ids = ids.tracks.unwrap_or_default();
+        let total = all_ids.len() as i32;
+        let page: Vec<i64> = all_ids
+            .into_iter()
+            .skip(offset as usize)
+            .take(limit as usize)
+            .collect();
+        let items = self.get_tracks_by_ids(&page).await?;
+        Ok(SearchResultItems {
+            items: Some(items),
+            total: Some(total),
+            offset: Some(offset as i32),
+            limit: Some(limit as i32),
+        })
+    }
+
+    pub async fn get_fav_albums(
+        &self,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<AlbumDto>> {
+        let ids = self.get_fav_ids().await?;
+        let all_ids = ids.albums.unwrap_or_default();
+        let total = all_ids.len() as i32;
+        let page: Vec<&str> = all_ids
+            .iter()
+            .skip(offset as usize)
+            .take(limit as usize)
+            .map(|s| s.as_str())
+            .collect();
+        let mut items = Vec::with_capacity(page.len());
+        for album_id in page {
+            match self.get_album(album_id).await {
+                Ok(a) => items.push(a),
+                Err(e) => eprintln!("[fav] failed to fetch album {}: {}", album_id, e),
+            }
+        }
+        Ok(SearchResultItems {
+            items: Some(items),
+            total: Some(total),
+            offset: Some(offset as i32),
+            limit: Some(limit as i32),
+        })
+    }
+
+    pub async fn get_fav_artists(
+        &self,
+        offset: u32,
+        limit: u32,
+    ) -> Result<SearchResultItems<FavArtistDto>> {
+        let ids = self.get_fav_ids().await?;
+        let all_ids = ids.artists.unwrap_or_default();
+        let total = all_ids.len() as i32;
+        let page: Vec<i64> = all_ids
+            .into_iter()
+            .skip(offset as usize)
+            .take(limit as usize)
+            .collect();
+        let mut items = Vec::with_capacity(page.len());
+        for artist_id in page {
+            match self.get_artist_page(artist_id).await {
+                Ok(v) => {
+                    let id = v.get("id").and_then(|i| i.as_i64());
+                    let name = v
+                        .get("name")
+                        .and_then(|n| n.get("display"))
+                        .and_then(|d| d.as_str())
+                        .map(|s| s.to_string());
+
+                    let mut image_dto = None;
+                    if let Some(imgs) = v.get("images") {
+                        if let Some(portrait) = imgs.get("portrait") {
+                            if let (Some(hash), Some(format)) = (
+                                portrait.get("hash").and_then(|h| h.as_str()),
+                                portrait.get("format").and_then(|f| f.as_str()),
+                            ) {
+                                image_dto = Some(ImageDto {
+                                    small: Some(format!("https://static.qobuz.com/images/artists/covers/small/{}.{}", hash, format)),
+                                    thumbnail: Some(format!("https://static.qobuz.com/images/artists/covers/small/{}.{}", hash, format)),
+                                    large: Some(format!("https://static.qobuz.com/images/artists/covers/large/{}.{}", hash, format)),
+                                    back: None,
+                                });
+                            }
+                        }
+                    }
+
+                    if id.is_some() && name.is_some() {
+                        items.push(FavArtistDto {
+                            id,
+                            name,
+                            albums_count: v
+                                .get("albums_count")
+                                .and_then(|c| c.as_i64())
+                                .map(|c| c as i32),
+                            image: image_dto,
+                        });
+                    }
+                }
+                Err(e) => eprintln!("[fav] failed to fetch artist {}: {}", artist_id, e),
+            }
+        }
+        Ok(SearchResultItems {
+            items: Some(items),
+            total: Some(total),
+            offset: Some(offset as i32),
+            limit: Some(limit as i32),
+        })
    }

    // --- Playlist management ---
@@ -343,7 +830,11 @@ impl QobuzClient {
    pub async fn create_playlist(&self, name: &str) -> Result<PlaylistDto> {
        let resp = self
            .post_request("playlist/create")
-            .form(&[("name", name), ("is_public", "false"), ("is_collaborative", "false")])
+            .form(&[
+                ("name", name),
+                ("is_public", "false"),
+                ("is_collaborative", "false"),
+            ])
            .send()
            .await?;
        let body = Self::check_response(resp).await?;
@@ -374,7 +865,11 @@ impl QobuzClient {
        Ok(())
    }

-    pub async fn delete_track_from_playlist(&self, playlist_id: i64, playlist_track_id: i64) -> Result<()> {
+    pub async fn delete_track_from_playlist(
+        &self,
+        playlist_id: i64,
+        playlist_track_id: i64,
+    ) -> Result<()> {
        let resp = self
            .post_request("playlist/deleteTracks")
            .form(&[
@@ -387,6 +882,26 @@ impl QobuzClient {
        Ok(())
    }

+    pub async fn subscribe_playlist(&self, playlist_id: i64) -> Result<()> {
+        let resp = self
+            .get_request("playlist/subscribe")
+            .query(&[("playlist_id", playlist_id.to_string())])
+            .send()
+            .await?;
+        Self::check_response(resp).await?;
+        Ok(())
+    }
+
+    pub async fn unsubscribe_playlist(&self, playlist_id: i64) -> Result<()> {
+        let resp = self
+            .get_request("playlist/unsubscribe")
+            .query(&[("playlist_id", playlist_id.to_string())])
+            .send()
+            .await?;
+        Self::check_response(resp).await?;
+        Ok(())
+    }
+
    pub async fn add_fav_track(&self, track_id: i64) -> Result<()> {
        let resp = self
            .get_request("favorite/create")
@@ -426,4 +941,24 @@ impl QobuzClient {
        Self::check_response(resp).await?;
        Ok(())
    }
+
+    pub async fn add_fav_artist(&self, artist_id: i64) -> Result<()> {
+        let resp = self
+            .get_request("favorite/create")
+            .query(&[("type", "artists"), ("artist_ids", &artist_id.to_string())])
+            .send()
+            .await?;
+        Self::check_response(resp).await?;
+        Ok(())
+    }
+
+    pub async fn remove_fav_artist(&self, artist_id: i64) -> Result<()> {
+        let resp = self
+            .get_request("favorite/delete")
+            .query(&[("type", "artists"), ("artist_ids", &artist_id.to_string())])
+            .send()
+            .await?;
+        Self::check_response(resp).await?;
+        Ok(())
+    }
 }
--- a/rust/src/api/models.rs
+++ b/rust/src/api/models.rs
@@ -46,6 +46,7 @@ pub struct SubscriptionDto {
 pub struct TrackDto {
    pub id: i64,
    pub title: Option<String>,
+    pub version: Option<String>,
    pub duration: Option<i64>,
    pub track_number: Option<i32>,
    pub playlist_track_id: Option<i64>,
@@ -73,12 +74,16 @@ pub struct AudioInfoDto {
 #[derive(Debug, Deserialize, Clone, Serialize)]
 pub struct TrackFileUrlDto {
    pub track_id: Option<i64>,
-    pub duration: Option<i64>,
+    pub duration: Option<f64>,
    pub url: Option<String>,
+    pub url_template: Option<String>,
+    pub n_segments: Option<u32>,
    pub format_id: Option<i32>,
    pub mime_type: Option<String>,
    pub sampling_rate: Option<f64>,
    pub bit_depth: Option<i32>,
+    /// qbz-1 encryption key: "qbz-1.<base64url_aes_key>.<base64url_iv>"
+    pub key: Option<String>,
 }

 // --- Album ---
@@ -98,6 +103,7 @@ pub struct AlbumDto {
    pub maximum_sampling_rate: Option<f64>,
    pub hires_streamable: Option<bool>,
    pub streamable: Option<bool>,
+    pub release_type: Option<String>,
    pub tracks: Option<TracksWrapper>,
 }

@@ -119,6 +125,10 @@ pub struct ArtistDto {
    pub image: Option<ImageDto>,
    pub biography: Option<BiographyDto>,
    pub albums: Option<SearchResultItems<AlbumDto>>,
+    #[serde(rename = "epSingles")]
+    pub ep_singles: Option<SearchResultItems<AlbumDto>>,
+    #[serde(rename = "liveAlbums")]
+    pub live_albums: Option<SearchResultItems<AlbumDto>>,
 }

 #[derive(Debug, Deserialize, Clone, Serialize)]
@@ -213,6 +223,15 @@ pub struct FavArtistDto {
    pub image: Option<ImageDto>,
 }

+// --- Favorite IDs ---
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct FavIdsDto {
+    pub tracks: Option<Vec<i64>>,
+    pub albums: Option<Vec<String>>,
+    pub artists: Option<Vec<i64>>,
+}
+
 // --- Format ---

 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@@ -238,30 +257,5 @@ impl Format {
        }
    }

-    pub fn label(self) -> &'static str {
-        match self {
-            Format::Mp3 => "MP3 320",
-            Format::Cd => "CD 16-bit",
-            Format::HiRes96 => "Hi-Res 24-bit/96kHz",
-            Format::HiRes192 => "Hi-Res 24-bit/192kHz",
-        }
 }

-    pub fn all() -> &'static [Format] {
-        &[Format::HiRes192, Format::HiRes96, Format::Cd, Format::Mp3]
-    }
-}
-
-// --- QWS ---
-
-#[derive(Debug, Deserialize, Clone, Serialize)]
-pub struct QwsTokenResponse {
-    pub jwt_qws: Option<QwsToken>,
-}
-
-#[derive(Debug, Deserialize, Clone, Serialize)]
-pub struct QwsToken {
-    pub exp: Option<i64>,
-    pub jwt: Option<String>,
-    pub endpoint: Option<String>,
-}
--- a/rust/src/lib.rs
+++ b/rust/src/lib.rs
--- a/rust/src/player/decoder.rs
+++ b/rust/src/player/decoder.rs
--- a/rust/src/player/mod.rs
+++ b/rust/src/player/mod.rs
@@ -1,4 +1,4 @@
-mod decoder;
+pub mod decoder;
 pub mod output;

 use std::sync::{
@@ -7,25 +7,27 @@ use std::sync::{
 };
 use std::time::Duration;

-use crate::api::{Format, TrackDto};
+use crate::api::TrackDto;
+use decoder::NextAction;

-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub enum PlayerCommand {
    Play(TrackInfo),
+    QueueNext(TrackInfo),
    Pause,
    Resume,
    Stop,
-    Seek(u64),
    SetVolume(u8),
 }

-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct TrackInfo {
    pub track: TrackDto,
    pub url: String,
-    pub format: Format,
-    /// ReplayGain track gain in dB, if enabled and available.
+    pub n_segments: u32,
+    pub encryption_key: Option<String>,
    pub replaygain_db: Option<f64>,
+    pub prefetch_data: Option<decoder::PrefetchData>,
 }

 #[derive(Debug, Clone, PartialEq)]
@@ -33,7 +35,6 @@ pub enum PlayerState {
    Idle,
    Playing,
    Paused,
-    Stopped,
    Error(String),
 }

@@ -44,14 +45,11 @@ pub struct PlayerStatus {
    pub duration_secs: Arc<AtomicU64>,
    pub volume: Arc<AtomicU8>,
    pub current_track: Arc<std::sync::Mutex<Option<TrackDto>>>,
-    /// Set to true by the decode thread when a track finishes naturally.
    pub track_finished: Arc<AtomicBool>,
-    /// Set by the player loop when a seek command arrives; cleared by the decode thread.
+    pub track_transitioned: Arc<AtomicBool>,
    pub seek_requested: Arc<AtomicBool>,
    pub seek_target_secs: Arc<AtomicU64>,
-    /// Linear gain factor to apply (1.0 = unity). Updated each time a new track starts.
    pub replaygain_gain: Arc<std::sync::Mutex<f32>>,
-    /// When false the audio output is torn down after each track, producing a gap.
    pub gapless: Arc<AtomicBool>,
 }

@@ -64,6 +62,7 @@ impl PlayerStatus {
            volume: Arc::new(AtomicU8::new(80)),
            current_track: Arc::new(std::sync::Mutex::new(None)),
            track_finished: Arc::new(AtomicBool::new(false)),
+            track_transitioned: Arc::new(AtomicBool::new(false)),
            seek_requested: Arc::new(AtomicBool::new(false)),
            seek_target_secs: Arc::new(AtomicU64::new(0)),
            replaygain_gain: Arc::new(std::sync::Mutex::new(1.0)),
@@ -74,22 +73,15 @@ impl PlayerStatus {
    pub fn get_state(&self) -> PlayerState {
        self.state.lock().unwrap().clone()
    }
-
    pub fn get_position(&self) -> u64 {
        self.position_secs.load(Ordering::Relaxed)
    }
-
    pub fn get_duration(&self) -> u64 {
        self.duration_secs.load(Ordering::Relaxed)
    }
-
    pub fn get_volume(&self) -> u8 {
        self.volume.load(Ordering::Relaxed)
    }
-
-    pub fn get_current_track(&self) -> Option<TrackDto> {
-        self.current_track.lock().unwrap().clone()
-    }
 }

 pub struct Player {
@@ -113,51 +105,45 @@ impl Player {
    pub fn send(&self, cmd: PlayerCommand) {
        self.cmd_tx.send(cmd).ok();
    }
-
    pub fn pause(&self) {
        self.send(PlayerCommand::Pause);
    }
-
    pub fn resume(&self) {
        self.send(PlayerCommand::Resume);
    }
-
    pub fn stop(&self) {
        self.send(PlayerCommand::Stop);
    }
-
    pub fn set_volume(&self, vol: u8) {
        self.status.volume.store(vol, Ordering::Relaxed);
        self.send(PlayerCommand::SetVolume(vol));
    }
-
    pub fn seek(&self, secs: u64) {
        self.status.seek_target_secs.store(secs, Ordering::Relaxed);
        self.status.seek_requested.store(true, Ordering::SeqCst);
    }
 }

-/// The player loop runs on a single dedicated OS thread.
-/// It owns the `AudioOutput` locally so there are no Send constraints.
-/// Decoding is performed inline; the command channel is polled via try_recv
-/// inside the decode loop to handle Pause/Resume/Seek/Stop/Play without
-/// tearng down and re-opening the audio device between tracks.
 fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatus) {
    use std::sync::mpsc::RecvTimeoutError;

    let mut audio_output: Option<output::AudioOutput> = None;
    let paused = Arc::new(AtomicBool::new(false));
-    // pending_info holds a Play command that interrupted an ongoing decode
-    let mut pending_info: Option<TrackInfo> = None;
+    let mut pending_action: Option<NextAction> = None;

    'outer: loop {
-        // Wait for a Play command (or use one that was interrupted)
-        let info = if let Some(p) = pending_info.take() {
-            p
+        let info = if let Some(action) = pending_action.take() {
+            match action {
+                NextAction::Play(info) | NextAction::Transition(info) => info,
+            }
        } else {
            loop {
                match rx.recv_timeout(Duration::from_millis(100)) {
                    Ok(PlayerCommand::Play(info)) => break info,
+                    Ok(PlayerCommand::QueueNext(info)) => {
+                        // If we are completely idle and get QueueNext, treat as Play
+                        break info;
+                    }
                    Ok(PlayerCommand::Stop) => {
                        audio_output = None;
                        paused.store(false, Ordering::SeqCst);
@@ -169,19 +155,15 @@ fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatu
                    Ok(PlayerCommand::SetVolume(v)) => {
                        status.volume.store(v, Ordering::Relaxed);
                    }
-                    Ok(PlayerCommand::Seek(s)) => {
-                        status.seek_target_secs.store(s, Ordering::Relaxed);
-                        status.seek_requested.store(true, Ordering::SeqCst);
-                    }
-                    Ok(_) => {} // Pause/Resume ignored when idle
+                    Ok(_) => {} // Ignore Pause/Resume when idle
                    Err(RecvTimeoutError::Timeout) => {}
                    Err(RecvTimeoutError::Disconnected) => break 'outer,
                }
            }
        };

-        // Compute ReplayGain factor
-        let rg_factor = info.replaygain_db
+        let rg_factor = info
+            .replaygain_db
            .map(|db| 10f32.powf(db as f32 / 20.0))
            .unwrap_or(1.0);
        *status.replaygain_gain.lock().unwrap() = rg_factor;
@@ -194,13 +176,17 @@ fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatu
        status.position_secs.store(0, Ordering::Relaxed);
        paused.store(false, Ordering::SeqCst);

-        match decoder::play_track_inline(&info.url, &status, &paused, &mut audio_output, &rx) {
-            Ok(Some(next_info)) => {
-                // Interrupted by a new Play — loop immediately with reused audio output
-                pending_info = Some(next_info);
+        // TrackInfo now directly passes the prefetch_data (if it exists) to the decoder
+        match decoder::play_track_inline(info, &status, &paused, &mut audio_output, &rx) {
+            Ok(Some(NextAction::Play(next_track))) => {
+                pending_action = Some(NextAction::Play(next_track));
+                // Interrupted by a manual play, no need to tell C++ to advance the queue
+            }
+            Ok(Some(NextAction::Transition(next_track))) => {
+                pending_action = Some(NextAction::Play(next_track));
+                status.track_transitioned.store(true, Ordering::SeqCst);
            }
            Ok(None) => {
-                // Track finished naturally — tear down audio output if gapless is off
                if !status.gapless.load(Ordering::Relaxed) {
                    audio_output = None;
                }
@@ -210,6 +196,7 @@ fn player_loop(rx: std::sync::mpsc::Receiver<PlayerCommand>, status: PlayerStatu
            Err(e) => {
                eprintln!("playback error: {e}");
                *status.state.lock().unwrap() = PlayerState::Error(e.to_string());
+                status.track_finished.store(true, Ordering::SeqCst);
            }
        }
    }
--- a/rust/src/player/output.rs
+++ b/rust/src/player/output.rs
@@ -3,7 +3,7 @@ use cpal::{
    traits::{DeviceTrait, HostTrait, StreamTrait},
    StreamConfig,
 };
-use rb::{RbConsumer, RbProducer, SpscRb, RB};
+use rb::{RbConsumer, RbInspector, RbProducer, SpscRb, RB};
 use std::sync::{
    atomic::{AtomicBool, Ordering},
    Arc,
@@ -13,6 +13,7 @@ use symphonia::core::audio::AudioBufferRef;
 const RING_BUFFER_SIZE: usize = 32 * 1024;

 pub struct AudioOutput {
+    _ring: SpscRb<f32>,
    ring_buf_producer: rb::Producer<f32>,
    _stream: cpal::Stream,
    pub sample_rate: u32,
@@ -50,6 +51,7 @@ impl AudioOutput {
        stream.play()?;

        Ok(Self {
+            _ring: ring,
            ring_buf_producer: producer,
            _stream: stream,
            sample_rate,
@@ -69,8 +71,13 @@ impl AudioOutput {
        );
        sample_buf.copy_interleaved_ref(decoded);
        let samples: Vec<f32> = sample_buf.samples().iter().map(|s| s * volume).collect();
+        self.write_samples(&samples, stop)
+    }

-        let mut remaining = &samples[..];
+    /// Write pre-converted interleaved f32 samples directly to the ring buffer.
+    /// Returns early (without error) if `stop` is set.
+    pub fn write_samples(&mut self, samples: &[f32], stop: &Arc<AtomicBool>) -> Result<()> {
+        let mut remaining = samples;
        while !remaining.is_empty() {
            if stop.load(Ordering::SeqCst) {
                return Ok(());
@@ -82,4 +89,14 @@ impl AudioOutput {
        }
        Ok(())
    }
+
+    #[allow(dead_code)]
+    pub fn flush(&self) {
+        // Wait until the ring buffer is fully emptied by cpal
+        while !self._ring.is_empty() {
+            std::thread::sleep(std::time::Duration::from_millis(10));
+        }
+        // Give the physical DAC an extra 100ms to output the last samples
+        std::thread::sleep(std::time::Duration::from_millis(100));
+    }
 }
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -25,6 +25,9 @@ target_sources(qobuz-qt PRIVATE
    view/albumlistview.hpp
    view/artistlistview.hpp
    view/artistview.hpp
+    view/artistview.cpp
+    view/genrebrowser.hpp
+    view/genrebrowser.cpp
    view/sidepanel/view.hpp
    view/sidepanel/view.cpp

@@ -55,3 +58,10 @@ target_sources(qobuz-qt PRIVATE
    util/icon.hpp
    util/settings.hpp
 )
+
+if (USE_DBUS)
+    target_sources(qobuz-qt PRIVATE
+        backend/mpris.hpp
+        backend/mpris.cpp
+    )
+endif ()
--- a/src/backend/mpris.cpp
+++ b/src/backend/mpris.cpp
@@ -0,0 +1,29 @@
+#include "mpris.hpp"
+
+#include <QDBusConnection>
+#include <QCoreApplication>
+#include <QProcess>
+
+MprisRootAdaptor::MprisRootAdaptor(QObject *parent)
+    : QDBusAbstractAdaptor(parent)
+{
+}
+
+MprisPlayerAdaptor::MprisPlayerAdaptor(QObject *parent)
+    : QDBusAbstractAdaptor(parent)
+{
+}
+
+Mpris::Mpris(QObject *parent)
+    : QObject(parent)
+{
+    m_root = new MprisRootAdaptor(this);
+    m_player = new MprisPlayerAdaptor(this);
+
+    QDBusConnection dbus = QDBusConnection::sessionBus();
+    QString serviceName = QString("org.mpris.MediaPlayer2.qobuz_qt.instance%1").arg(QCoreApplication::applicationPid());
+    
+    dbus.registerService(serviceName);
+    dbus.registerObject("/org/mpris/MediaPlayer2", this, 
+                        QDBusConnection::ExportAdaptors);
+}
--- a/src/backend/mpris.hpp
+++ b/src/backend/mpris.hpp
@@ -0,0 +1,165 @@
+#pragma once
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QVariantMap>
+#include <QDBusAbstractAdaptor>
+#include <QDBusObjectPath>
+
+class MprisRootAdaptor : public QDBusAbstractAdaptor
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "org.mpris.MediaPlayer2")
+    
+    Q_PROPERTY(bool CanQuit READ canQuit)
+    Q_PROPERTY(bool Fullscreen READ fullscreen WRITE setFullscreen)
+    Q_PROPERTY(bool CanSetFullscreen READ canSetFullscreen)
+    Q_PROPERTY(bool CanRaise READ canRaise)
+    Q_PROPERTY(bool HasTrackList READ hasTrackList)
+    Q_PROPERTY(QString Identity READ identity)
+    Q_PROPERTY(QString DesktopEntry READ desktopEntry)
+    Q_PROPERTY(QStringList SupportedUriSchemes READ supportedUriSchemes)
+    Q_PROPERTY(QStringList SupportedMimeTypes READ supportedMimeTypes)
+
+public:
+    explicit MprisRootAdaptor(QObject *parent);
+
+    bool canQuit() const { return true; }
+    bool fullscreen() const { return false; }
+    void setFullscreen(bool) {}
+    bool canSetFullscreen() const { return false; }
+    bool canRaise() const { return true; }
+    bool hasTrackList() const { return false; } 
+    QString identity() const { return "Qobuz"; }
+    QString desktopEntry() const { return "qobuz-qt"; }
+    QStringList supportedUriSchemes() const { return {}; }
+    QStringList supportedMimeTypes() const { return {}; }
+
+public slots:
+    void Quit() { emit quitRequested(); }
+    void Raise() { emit raiseRequested(); }
+
+signals:
+    void quitRequested();
+    void raiseRequested();
+};
+
+class MprisPlayerAdaptor : public QDBusAbstractAdaptor
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "org.mpris.MediaPlayer2.Player")
+
+    Q_PROPERTY(QString PlaybackStatus READ playbackStatus NOTIFY playbackStatusChanged)
+    Q_PROPERTY(QString LoopStatus READ loopStatus WRITE setLoopStatus)
+    Q_PROPERTY(double Rate READ rate WRITE setRate)
+    Q_PROPERTY(bool Shuffle READ shuffle WRITE setShuffle)
+    Q_PROPERTY(QVariantMap Metadata READ metadata NOTIFY metadataChanged)
+    Q_PROPERTY(double Volume READ volume WRITE setVolume NOTIFY volumeChanged)
+    Q_PROPERTY(qlonglong Position READ position)
+    Q_PROPERTY(double MinimumRate READ minimumRate)
+    Q_PROPERTY(double MaximumRate READ maximumRate)
+    Q_PROPERTY(bool CanGoNext READ canGoNext)
+    Q_PROPERTY(bool CanGoPrevious READ canGoPrevious)
+    Q_PROPERTY(bool CanPlay READ canPlay)
+    Q_PROPERTY(bool CanPause READ canPause)
+    Q_PROPERTY(bool CanSeek READ canSeek)
+    Q_PROPERTY(bool CanControl READ canControl)
+
+public:
+    explicit MprisPlayerAdaptor(QObject *parent);
+
+    QString playbackStatus() const { return m_playbackStatus; }
+    void setPlaybackStatus(const QString &s) {
+        if (m_playbackStatus != s) {
+            m_playbackStatus = s;
+            emit playbackStatusChanged();
+        }
+    }
+
+    QString loopStatus() const { return "None"; }
+    void setLoopStatus(const QString &) {}
+
+    double rate() const { return 1.0; }
+    void setRate(double) {}
+
+    bool shuffle() const { return false; }
+    void setShuffle(bool) {}
+
+    QVariantMap metadata() const { return m_metadata; }
+    void setMetadata(const QVariantMap &m) { 
+        m_metadata = m; 
+        emit metadataChanged(); 
+    }
+
+    double volume() const { return m_volume; }
+    void setVolume(double v) { 
+        emit volumeChangeRequested(v); 
+    }
+    void updateVolume(double v) {
+        if (m_volume != v) {
+            m_volume = v;
+            emit volumeChanged();
+        }
+    }
+
+    qlonglong position() const { return m_positionMicro; }
+    void updatePosition(qlonglong posSecs) { m_positionMicro = posSecs * 1000000LL; }
+
+    double minimumRate() const { return 1.0; }
+    double maximumRate() const { return 1.0; }
+
+    bool canGoNext() const { return true; }
+    bool canGoPrevious() const { return true; }
+    bool canPlay() const { return true; }
+    bool canPause() const { return true; }
+    bool canSeek() const { return true; }
+    bool canControl() const { return true; }
+
+public slots:
+    void Next() { emit nextRequested(); }
+    void Previous() { emit previousRequested(); }
+    void Pause() { emit pauseRequested(); }
+    void PlayPause() { emit playPauseRequested(); }
+    void Stop() { emit stopRequested(); }
+    void Play() { emit playRequested(); }
+    void Seek(qlonglong offset) { emit seekRequested(offset); }
+    void SetPosition(const QDBusObjectPath &trackId, qlonglong position) { Q_UNUSED(trackId); emit seekToRequested(position); }
+    void OpenUri(const QString &uri) { Q_UNUSED(uri); }
+
+signals:
+    void playbackStatusChanged();
+    void metadataChanged();
+    void volumeChanged();
+
+    // Commands to MainWindow
+    void playRequested();
+    void pauseRequested();
+    void playPauseRequested();
+    void stopRequested();
+    void nextRequested();
+    void previousRequested();
+    void seekRequested(qlonglong offsetMicroseconds);
+    void seekToRequested(qlonglong positionMicroseconds);
+    void volumeChangeRequested(double volume);
+
+private:
+    QString m_playbackStatus = "Stopped";
+    QVariantMap m_metadata;
+    double m_volume = 1.0;
+    qlonglong m_positionMicro = 0;
+};
+
+class Mpris : public QObject
+{
+    Q_OBJECT
+public:
+    explicit Mpris(QObject *parent = nullptr);
+
+    MprisRootAdaptor *root() const { return m_root; }
+    MprisPlayerAdaptor *player() const { return m_player; }
+
+private:
+    MprisRootAdaptor *m_root;
+    MprisPlayerAdaptor *m_player;
+};
--- a/src/backend/qobuzbackend.cpp
+++ b/src/backend/qobuzbackend.cpp
@@ -8,6 +8,10 @@ QobuzBackend::QobuzBackend(QObject *parent)
    : QObject(parent)
 {
    m_backend = qobuz_backend_new(&QobuzBackend::eventTrampoline, this);
+    if (!m_backend) {
+        qCritical("Failed to initialize Qobuz backend");
+        return;
+    }

    m_positionTimer = new QTimer(this);
    m_positionTimer->setInterval(50);
@@ -35,6 +39,11 @@ void QobuzBackend::setToken(const QString &token)
    qobuz_backend_set_token(m_backend, token.toUtf8().constData());
 }

+void QobuzBackend::getUser()
+{
+    qobuz_backend_get_user(m_backend);
+}
+
 // ---- catalog ----

 void QobuzBackend::search(const QString &query, quint32 offset, quint32 limit)
@@ -42,6 +51,22 @@ void QobuzBackend::search(const QString &query, quint32 offset, quint32 limit)
    qobuz_backend_search(m_backend, query.toUtf8().constData(), offset, limit);
 }

+void QobuzBackend::mostPopularSearch(const QString &query, quint32 limit)
+{
+    qobuz_backend_most_popular_search(m_backend, query.toUtf8().constData(), limit);
+}
+
+void QobuzBackend::getDynamicSuggestions(const QJsonArray &listenedTrackIds, const QJsonArray &tracksToAnalyze, quint32 limit)
+{
+    const QByteArray listened = QJsonDocument(listenedTrackIds).toJson(QJsonDocument::Compact);
+    const QByteArray analyze = QJsonDocument(tracksToAnalyze).toJson(QJsonDocument::Compact);
+    qobuz_backend_get_dynamic_suggestions(
+        m_backend,
+        listened.constData(),
+        analyze.constData(),
+        limit);
+}
+
 void QobuzBackend::getAlbum(const QString &albumId)
 {
    qobuz_backend_get_album(m_backend, albumId.toUtf8().constData());
@@ -52,11 +77,59 @@ void QobuzBackend::getArtist(qint64 artistId)
    qobuz_backend_get_artist(m_backend, artistId);
 }

+void QobuzBackend::getArtistReleases(qint64 artistId, const QString &releaseType, quint32 limit, quint32 offset)
+{
+    qobuz_backend_get_artist_releases(m_backend, artistId,
+                                      releaseType.toUtf8().constData(), limit, offset);
+}
+
+void QobuzBackend::getAlbumsTracks(const QStringList &albumIds)
+{
+    const QJsonArray arr = QJsonArray::fromStringList(albumIds);
+    const QByteArray json = QJsonDocument(arr).toJson(QJsonDocument::Compact);
+    qobuz_backend_get_albums_tracks(m_backend, json.constData());
+}
+
 void QobuzBackend::getPlaylist(qint64 playlistId, quint32 offset, quint32 limit)
 {
    qobuz_backend_get_playlist(m_backend, playlistId, offset, limit);
 }

+void QobuzBackend::getPlaylistAll(qint64 playlistId)
+{
+    qobuz_backend_get_playlist_all(m_backend, playlistId);
+}
+
+void QobuzBackend::getGenres()
+{
+    qobuz_backend_get_genres(m_backend);
+}
+
+void QobuzBackend::getFeaturedAlbums(const QString &genreIds, const QString &kind, quint32 limit, quint32 offset)
+{
+    qobuz_backend_get_featured_albums(m_backend, genreIds.toUtf8().constData(), kind.toUtf8().constData(), limit, offset);
+}
+
+void QobuzBackend::getFeaturedPlaylists(const QString &genreIds, const QString &kind, quint32 limit, quint32 offset)
+{
+    qobuz_backend_get_featured_playlists(m_backend, genreIds.toUtf8().constData(), kind.toUtf8().constData(), limit, offset);
+}
+
+void QobuzBackend::discoverPlaylists(const QString &genreIds, const QString &tags, quint32 limit, quint32 offset)
+{
+    qobuz_backend_discover_playlists(
+        m_backend,
+        genreIds.toUtf8().constData(),
+        tags.toUtf8().constData(),
+        limit,
+        offset);
+}
+
+void QobuzBackend::searchPlaylists(const QString &query, quint32 limit, quint32 offset)
+{
+    qobuz_backend_search_playlists(m_backend, query.toUtf8().constData(), limit, offset);
+}
+
 // ---- favorites ----

 void QobuzBackend::getFavTracks(quint32 offset, quint32 limit)
@@ -118,6 +191,16 @@ void QobuzBackend::deleteTrackFromPlaylist(qint64 playlistId, qint64 playlistTra
    qobuz_backend_delete_track_from_playlist(m_backend, playlistId, playlistTrackId);
 }

+void QobuzBackend::subscribePlaylist(qint64 playlistId)
+{
+    qobuz_backend_subscribe_playlist(m_backend, playlistId);
+}
+
+void QobuzBackend::unsubscribePlaylist(qint64 playlistId)
+{
+    qobuz_backend_unsubscribe_playlist(m_backend, playlistId);
+}
+
 // ---- fav modification ----

 void QobuzBackend::addFavTrack(qint64 trackId)
@@ -140,6 +223,16 @@ void QobuzBackend::removeFavAlbum(const QString &albumId)
    qobuz_backend_remove_fav_album(m_backend, albumId.toUtf8().constData());
 }

+void QobuzBackend::addFavArtist(qint64 artistId)
+{
+    qobuz_backend_add_fav_artist(m_backend, artistId);
+}
+
+void QobuzBackend::removeFavArtist(qint64 artistId)
+{
+    qobuz_backend_remove_fav_artist(m_backend, artistId);
+}
+
 // ---- playback ----

 void QobuzBackend::playTrack(qint64 trackId, int formatId)
@@ -185,11 +278,19 @@ void QobuzBackend::onPositionTick()

    if (qobuz_backend_take_track_finished(m_backend))
        emit trackFinished();
+        
+    if (qobuz_backend_take_track_transitioned(m_backend))
+        emit trackTransitioned();
 }

 void QobuzBackend::onEvent(int eventType, const QString &json)
 {
-    const QJsonObject obj = QJsonDocument::fromJson(json.toUtf8()).object();
+    const QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
+    if (!doc.isObject()) {
+        emit error(tr("Malformed response from backend"));
+        return;
+    }
+    const QJsonObject obj = doc.object();

    switch (eventType) {
    case EV_LOGIN_OK:
@@ -201,6 +302,9 @@ void QobuzBackend::onEvent(int eventType, const QString &json)
    case EV_SEARCH_OK:
        emit searchResult(obj);
        break;
+    case EV_MOST_POPULAR_OK:
+        emit mostPopularResult(obj);
+        break;
    case EV_SEARCH_ERR:
        emit error(obj["error"].toString());
        break;
@@ -213,6 +317,35 @@ void QobuzBackend::onEvent(int eventType, const QString &json)
    case EV_ARTIST_OK:
        emit artistLoaded(obj);
        break;
+    case EV_ARTIST_RELEASES_OK:
+        emit artistReleasesLoaded(
+            obj["release_type"].toString(),
+            obj["items"].toArray(),
+            obj["has_more"].toBool(),
+            obj["offset"].toInt()
+        );
+        break;
+    case EV_DEEP_SHUFFLE_OK:
+        emit deepShuffleTracksLoaded(obj["tracks"].toArray());
+        break;
+    case EV_DYNAMIC_SUGGEST_OK:
+        emit dynamicSuggestionsLoaded(obj);
+        break;
+    case EV_GENRES_OK:
+        emit genresLoaded(obj);
+        break;
+    case EV_FEATURED_ALBUMS_OK:
+        emit featuredAlbumsLoaded(obj);
+        break;
+    case EV_FEATURED_PLAYLISTS_OK:
+        emit featuredPlaylistsLoaded(obj);
+        break;
+    case EV_DISCOVER_PLAYLISTS_OK:
+        emit discoverPlaylistsLoaded(obj);
+        break;
+    case EV_PLAYLIST_SEARCH_OK:
+        emit playlistSearchLoaded(obj);
+        break;
    case EV_ARTIST_ERR:
        emit error(obj["error"].toString());
        break;
@@ -240,15 +373,24 @@ void QobuzBackend::onEvent(int eventType, const QString &json)
    case EV_STATE_CHANGED:
        emit stateChanged(obj["state"].toString());
        break;
-    case 20: // EV_PLAYLIST_CREATED
+    case EV_PLAYLIST_CREATED:
        emit playlistCreated(obj);
        break;
-    case 21: // EV_PLAYLIST_DELETED
+    case EV_PLAYLIST_DELETED:
        emit playlistDeleted(obj);
        break;
-    case 22: // EV_PLAYLIST_TRACK_ADDED
+    case EV_PLAYLIST_TRACK_ADDED:
        emit playlistTrackAdded(static_cast<qint64>(obj["playlist_id"].toDouble()));
        break;
+    case EV_PLAYLIST_SUBSCRIBED:
+        emit playlistSubscribed(static_cast<qint64>(obj["playlist_id"].toDouble()));
+        break;
+    case EV_PLAYLIST_UNSUBSCRIBED:
+        emit playlistUnsubscribed(static_cast<qint64>(obj["playlist_id"].toDouble()));
+        break;
+    case EV_USER_OK:
+        emit userLoaded(obj);
+        break;
    case EV_GENERIC_ERR:
    case EV_TRACK_URL_ERR:
        emit error(obj["error"].toString());
--- a/src/backend/qobuzbackend.hpp
+++ b/src/backend/qobuzbackend.hpp
@@ -4,6 +4,7 @@

 #include <QObject>
 #include <QString>
+#include <QJsonArray>
 #include <QJsonObject>
 #include <QTimer>

@@ -23,18 +24,29 @@ public:
    // --- auth ---
    void login(const QString &email, const QString &password);
    void setToken(const QString &token);
+    void getUser();

    // --- catalog ---
    void search(const QString &query, quint32 offset = 0, quint32 limit = 20);
+    void mostPopularSearch(const QString &query, quint32 limit = 8);
+    void getDynamicSuggestions(const QJsonArray &listenedTrackIds, const QJsonArray &tracksToAnalyze, quint32 limit = 50);
    void getAlbum(const QString &albumId);
    void getArtist(qint64 artistId);
+    void getArtistReleases(qint64 artistId, const QString &releaseType, quint32 limit = 50, quint32 offset = 0);
+    void getAlbumsTracks(const QStringList &albumIds);
    void getPlaylist(qint64 playlistId, quint32 offset = 0, quint32 limit = 500);
+    void getPlaylistAll(qint64 playlistId);
+    void getGenres();
+    void getFeaturedAlbums(const QString &genreIds, const QString &kind, quint32 limit = 50, quint32 offset = 0);
+    void getFeaturedPlaylists(const QString &genreIds, const QString &kind, quint32 limit = 25, quint32 offset = 0);
+    void discoverPlaylists(const QString &genreIds, const QString &tags = QString(), quint32 limit = 25, quint32 offset = 0);
+    void searchPlaylists(const QString &query, quint32 limit = 8, quint32 offset = 0);

    // --- favorites ---
    void getFavTracks(quint32 offset = 0, quint32 limit = 500);
    void getFavAlbums(quint32 offset = 0, quint32 limit = 200);
    void getFavArtists(quint32 offset = 0, quint32 limit = 200);
-    void getUserPlaylists(quint32 offset = 0, quint32 limit = 200);
+    void getUserPlaylists(quint32 offset = 0, quint32 limit = 350);

    // --- playback options ---
    void setReplayGain(bool enabled);
@@ -46,12 +58,16 @@ public:
    void deletePlaylist(qint64 playlistId);
    void addTrackToPlaylist(qint64 playlistId, qint64 trackId);
    void deleteTrackFromPlaylist(qint64 playlistId, qint64 playlistTrackId);
+    void subscribePlaylist(qint64 playlistId);
+    void unsubscribePlaylist(qint64 playlistId);

    // --- fav modification ---
    void addFavTrack(qint64 trackId);
    void removeFavTrack(qint64 trackId);
    void addFavAlbum(const QString &albumId);
    void removeFavAlbum(const QString &albumId);
+    void addFavArtist(qint64 artistId);
+    void removeFavArtist(qint64 artistId);

    // --- playback ---
    void playTrack(qint64 trackId, int formatId = 6);
@@ -71,15 +87,27 @@ signals:
    // auth
    void loginSuccess(const QString &token, const QJsonObject &user);
    void loginError(const QString &error);
+    void userLoaded(const QJsonObject &user);

    // catalog
    void searchResult(const QJsonObject &result);
+    void mostPopularResult(const QJsonObject &result);
    void albumLoaded(const QJsonObject &album);
    void artistLoaded(const QJsonObject &artist);
+    void artistReleasesLoaded(const QString &releaseType, const QJsonArray &items, bool hasMore, int offset);
+    void deepShuffleTracksLoaded(const QJsonArray &tracks);
+    void dynamicSuggestionsLoaded(const QJsonObject &result);
+    void genresLoaded(const QJsonObject &result);
+    void featuredAlbumsLoaded(const QJsonObject &result);
+    void featuredPlaylistsLoaded(const QJsonObject &result);
+    void discoverPlaylistsLoaded(const QJsonObject &result);
+    void playlistSearchLoaded(const QJsonObject &result);
    void playlistLoaded(const QJsonObject &playlist);
    void playlistCreated(const QJsonObject &playlist);
    void playlistDeleted(const QJsonObject &result);
    void playlistTrackAdded(qint64 playlistId);
+    void playlistSubscribed(qint64 playlistId);
+    void playlistUnsubscribed(qint64 playlistId);

    // favorites
    void favTracksLoaded(const QJsonObject &result);
@@ -92,6 +120,7 @@ signals:
    void stateChanged(const QString &state);
    void positionChanged(quint64 position, quint64 duration);
    void trackFinished();
+    void trackTransitioned();

    // errors
    void error(const QString &message);
@@ -100,6 +129,11 @@ private slots:
    Q_INVOKABLE void onEvent(int eventType, const QString &json);
    void onPositionTick();

+public:
+    void manuallyEmitTrackChanged(const QJsonObject &track) {
+        emit trackChanged(track);
+    }
+
 private:
    QobuzBackendOpaque *m_backend = nullptr;
    QTimer *m_positionTimer = nullptr;
--- a/src/list/library.cpp
+++ b/src/list/library.cpp
@@ -20,6 +20,8 @@ enum NodeType {
    NodeFavAlbums,
    NodeFavArtists,
    NodePlaylist,
+    NodeBrowseGenres,
+    NodeBrowsePlaylists,
 };

 Library::Library(QobuzBackend *backend, QWidget *parent)
@@ -71,6 +73,16 @@ void Library::buildStaticNodes()
    // Playlists
    m_playlistsNode = new QTreeWidgetItem(this, QStringList{tr("Playlists")});
    m_playlistsNode->setExpanded(true);
+
+    // Browse
+    m_browseNode = new QTreeWidgetItem(this, QStringList{tr("Browse")});
+    m_browseNode->setExpanded(true);
+
+    auto *genresItem = new QTreeWidgetItem(m_browseNode, QStringList{tr("Genres")});
+    genresItem->setData(0, TypeRole, NodeBrowseGenres);
+
+    auto *playlistsItem = new QTreeWidgetItem(m_browseNode, QStringList{tr("Playlists")});
+    playlistsItem->setData(0, TypeRole, NodeBrowsePlaylists);
 }

 void Library::refresh()
@@ -87,6 +99,7 @@ void Library::onUserPlaylistsLoaded(const QJsonObject &result)
    while (m_playlistsNode->childCount() > 0)
        delete m_playlistsNode->takeChild(0);

+    QSet<qint64> allPlaylistIds;
    QVector<QPair<qint64, QString>> editablePlaylists;
    const qint64 myUserId = AppSettings::instance().userId();
    const QJsonArray items = result["items"].toArray();
@@ -97,6 +110,9 @@ void Library::onUserPlaylistsLoaded(const QJsonObject &result)
        const qint64      ownId = static_cast<qint64>(pl["owner"].toObject()["id"].toDouble());
        const bool        isOwner = (myUserId > 0 && ownId == myUserId);

+        if (id > 0)
+            allPlaylistIds.insert(id);
+
        auto *item = new QTreeWidgetItem(m_playlistsNode, QStringList{name});
        item->setData(0, TypeRole,    NodePlaylist);
        item->setData(0, IdRole,      id);
@@ -108,6 +124,7 @@ void Library::onUserPlaylistsLoaded(const QJsonObject &result)
            editablePlaylists.append({id, name});
    }

+    emit userPlaylistIdsChanged(allPlaylistIds);
    emit userPlaylistsChanged(editablePlaylists);
 }

@@ -167,6 +184,8 @@ void Library::onItemClicked(QTreeWidgetItem *item, int)
    case NodeFavTracks:  emit favTracksRequested();  break;
    case NodeFavAlbums:  emit favAlbumsRequested();  break;
    case NodeFavArtists: emit favArtistsRequested(); break;
+    case NodeBrowseGenres: emit browseGenresRequested(); break;
+    case NodeBrowsePlaylists: emit browsePlaylistsRequested(); break;
    case NodePlaylist: {
        const qint64  id   = item->data(0, IdRole).toLongLong();
        const QString name = item->data(0, NameRole).toString();
--- a/src/list/library.hpp
+++ b/src/list/library.hpp
@@ -7,6 +7,7 @@
 #include <QVector>
 #include <QPair>
 #include <QString>
+#include <QSet>

 namespace List
 {
@@ -26,9 +27,13 @@ namespace List
        void favTracksRequested();
        void favAlbumsRequested();
        void favArtistsRequested();
+        void browseGenresRequested();
+        void browsePlaylistsRequested();
        void playlistRequested(qint64 playlistId, const QString &name);
        /// Emitted after playlists are loaded so others can cache the list.
        void userPlaylistsChanged(const QVector<QPair<qint64, QString>> &playlists);
+        /// Emitted with all user playlist IDs (owned + subscribed).
+        void userPlaylistIdsChanged(const QSet<qint64> &playlistIds);
        /// Emitted when the currently open playlist was deleted.
        void openPlaylistDeleted();

@@ -43,6 +48,7 @@ namespace List

        QTreeWidgetItem *m_myLibNode     = nullptr;
        QTreeWidgetItem *m_playlistsNode = nullptr;
+        QTreeWidgetItem *m_browseNode    = nullptr;
        qint64           m_openPlaylistId = 0;

        void buildStaticNodes();
--- a/src/list/tracks.cpp
+++ b/src/list/tracks.cpp
@@ -1,9 +1,11 @@
 #include "tracks.hpp"
 #include "../util/settings.hpp"
+#include "../util/trackinfo.hpp"

 #include <QHeaderView>
 #include <QMenu>
 #include <QAction>
+#include <QScrollBar>

 namespace List
 {
@@ -35,43 +37,138 @@ Tracks::Tracks(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
            this, &Tracks::onDoubleClicked);
    connect(this, &QTreeView::customContextMenuRequested,
            this, &Tracks::onContextMenu);
+    connect(m_model, &QAbstractItemModel::modelReset, this, [this] {
+        for (int row : m_model->discHeaderRows())
+            setFirstColumnSpanned(row, {}, true);
+        setSortingEnabled(!m_model->hasMultipleDiscs());
+    });
+    connect(verticalScrollBar(), &QScrollBar::valueChanged,
+            this, [this](int) { maybeLoadMorePlaylistTracks(); });
+
+    connect(m_backend, &QobuzBackend::playlistLoaded, this,
+            [this](const QJsonObject &playlist) {
+        if (!m_pendingPlayAll)
+            return;
+
+        const qint64 id = static_cast<qint64>(playlist["id"].toDouble());
+        if (id != m_playlistId)
+            return;
+
+        if (!playlist["full_load"].toBool())
+            return;
+
+        m_pendingPlayAll = false;
+        const bool shuffle = m_pendingPlayAllShuffle;
+        m_pendingPlayAllShuffle = false;
+
+        const QJsonArray items = playlist["tracks"].toObject()["items"].toArray();
+        if (items.isEmpty())
+            return;
+
+        m_queue->setContext(items, 0);
+        if (shuffle && !m_queue->shuffleEnabled())
+            m_queue->shuffleNow();
+
+        const qint64 firstId = static_cast<qint64>(m_queue->current()["id"].toDouble());
+        if (firstId > 0)
+            emit playTrackRequested(firstId);
+    });

 }

 void Tracks::loadTracks(const QJsonArray &tracks)
 {
    setPlaylistContext(0);
+    m_pendingPlayAll = false;
+    m_pendingPlayAllShuffle = false;
+    setColumnHidden(TrackListModel::ColAlbum, false);
    m_model->setTracks(tracks, false, /*useSequential=*/true);
 }

 void Tracks::loadAlbum(const QJsonObject &album)
 {
    setPlaylistContext(0);
+    m_pendingPlayAll = false;
+    m_pendingPlayAllShuffle = false;
+    setColumnHidden(TrackListModel::ColAlbum, true);
    const QJsonArray items = album["tracks"].toObject()["items"].toArray();
    m_model->setTracks(items); // album: use track_number
 }

 void Tracks::loadPlaylist(const QJsonObject &playlist)
 {
+    setColumnHidden(TrackListModel::ColAlbum, false);
    const qint64 id     = static_cast<qint64>(playlist["id"].toDouble());
    const qint64 ownId  = static_cast<qint64>(playlist["owner"].toObject()["id"].toDouble());
    const qint64 myId   = AppSettings::instance().userId();
    const bool isOwned  = (myId > 0 && ownId == myId);
    setPlaylistContext(id, isOwned);
-    const QJsonArray items = playlist["tracks"].toObject()["items"].toArray();
+    const QJsonObject tracksObj = playlist["tracks"].toObject();
+    const QJsonArray items = tracksObj["items"].toArray();
+    const int offset = tracksObj["offset"].toInt(0);
+    m_playlistTrackTotal = tracksObj["total"].toInt(items.size());
+    m_playlistLoadedCount = offset + items.size();
+    m_playlistLoadingMore = false;
    m_model->setTracks(items, /*usePosition=*/true);
+    maybeLoadMorePlaylistTracks();
+}
+
+void Tracks::appendPlaylistPage(const QJsonObject &playlist)
+{
+    if (m_playlistId <= 0)
+        return;
+
+    const qint64 id = static_cast<qint64>(playlist["id"].toDouble());
+    if (id != m_playlistId)
+        return;
+
+    const QJsonObject tracksObj = playlist["tracks"].toObject();
+    const QJsonArray items = tracksObj["items"].toArray();
+    const int offset = tracksObj["offset"].toInt(m_playlistLoadedCount);
+    const int total = tracksObj["total"].toInt(m_playlistTrackTotal);
+
+    if (total > 0)
+        m_playlistTrackTotal = total;
+
+    // Ignore stale/duplicate pages.
+    if (offset < m_playlistLoadedCount) {
+        m_playlistLoadingMore = false;
+        return;
+    }
+
+    if (!items.isEmpty()) {
+        m_model->appendTracks(items, /*usePosition=*/true);
+        m_playlistLoadedCount = offset + items.size();
+    } else {
+        m_playlistLoadedCount = qMax(m_playlistLoadedCount, offset);
+    }
+
+    m_playlistLoadingMore = false;
+    maybeLoadMorePlaylistTracks();
 }

 void Tracks::loadSearchTracks(const QJsonArray &tracks)
 {
    setPlaylistContext(0);
+    m_pendingPlayAll = false;
+    m_pendingPlayAllShuffle = false;
+    setColumnHidden(TrackListModel::ColAlbum, false);
    m_model->setTracks(tracks, false, /*useSequential=*/true);
 }

 void Tracks::setPlaylistContext(qint64 playlistId, bool isOwned)
 {
+    if (m_playlistId != playlistId) {
+        m_pendingPlayAll = false;
+        m_pendingPlayAllShuffle = false;
+        m_playlistLoadingMore = false;
+    }
    m_playlistId = playlistId;
    m_playlistIsOwned = isOwned;
+    if (playlistId <= 0) {
+        m_playlistTrackTotal = 0;
+        m_playlistLoadedCount = 0;
+    }
 }

 void Tracks::setUserPlaylists(const QVector<QPair<qint64, QString>> &playlists)
@@ -84,23 +181,77 @@ void Tracks::setPlayingTrackId(qint64 id)
    m_model->setPlayingId(id);
 }

+void Tracks::setFavTrackIds(const QSet<qint64> &ids)
+{
+    m_model->setFavIds(ids);
+}
+
+void Tracks::addFavTrackId(qint64 id)
+{
+    m_model->addFavId(id);
+}
+
+void Tracks::removeFavTrackId(qint64 id)
+{
+    m_model->removeFavId(id);
+}
+
 void Tracks::playAll(bool shuffle)
 {
    const QJsonArray tracks = m_model->currentTracksJson();
    if (tracks.isEmpty()) return;
-    m_queue->setShuffle(shuffle);
+
+    if (m_playlistId > 0 && m_playlistTrackTotal > tracks.size()) {
+        m_pendingPlayAll = true;
+        m_pendingPlayAllShuffle = shuffle;
+        m_backend->getPlaylistAll(m_playlistId);
+        return;
+    }
+
    m_queue->setContext(tracks, 0);
+    // Shuffle once without touching the global shuffle flag — so a subsequent
+    // double-click on a track plays in normal order (unless global shuffle is on).
+    if (shuffle && !m_queue->shuffleEnabled())
+        m_queue->shuffleNow();
    const qint64 firstId = static_cast<qint64>(m_queue->current()["id"].toDouble());
    if (firstId > 0)
        emit playTrackRequested(firstId);
 }

+void Tracks::maybeLoadMorePlaylistTracks()
+{
+    if (m_playlistId <= 0)
+        return;
+    if (m_pendingPlayAll)
+        return;
+    if (m_playlistLoadingMore)
+        return;
+    if (m_playlistTrackTotal > 0 && m_playlistLoadedCount >= m_playlistTrackTotal)
+        return;
+
+    QScrollBar *bar = verticalScrollBar();
+    if (!bar)
+        return;
+
+    // Start prefetching before the absolute bottom so paging feels seamless.
+    constexpr int kPrefetchPx = 180;
+    if (bar->maximum() > 0 && bar->value() < (bar->maximum() - kPrefetchPx))
+        return;
+
+    m_playlistLoadingMore = true;
+    m_backend->getPlaylist(m_playlistId, static_cast<quint32>(m_playlistLoadedCount), 500);
+}
+

 void Tracks::onDoubleClicked(const QModelIndex &index)
 {
    const qint64 id = m_model->data(index, TrackListModel::TrackIdRole).toLongLong();
    if (id > 0) {
-        m_queue->setContext(m_model->currentTracksJson(), index.row());
+        // Compute filtered row (disc headers excluded from currentTracksJson)
+        int filteredRow = 0;
+        for (int r = 0; r < index.row(); ++r)
+            if (!m_model->trackAt(r).isDiscHeader) ++filteredRow;
+        m_queue->setContext(m_model->currentTracksJson(), filteredRow);
        emit playTrackRequested(id);
    }
 }
@@ -111,6 +262,7 @@ void Tracks::onContextMenu(const QPoint &pos)
    if (!index.isValid()) return;

    const qint64      id        = m_model->data(index, TrackListModel::TrackIdRole).toLongLong();
+    if (id <= 0) return;  // disc header row
    const QJsonObject trackJson = m_model->data(index, TrackListModel::TrackJsonRole).toJsonObject();

    QMenu menu(this);
@@ -119,12 +271,28 @@ void Tracks::onContextMenu(const QPoint &pos)
    auto *playNext = menu.addAction(QIcon(":/res/icons/media-skip-forward.svg"),   tr("Play next"));
    auto *addQueue = menu.addAction(QIcon(":/res/icons/media-playlist-append.svg"), tr("Add to queue"));
    menu.addSeparator();
-    auto *addFav   = menu.addAction(QIcon(":/res/icons/starred-symbolic.svg"),      tr("Add to favorites"));
-    auto *remFav   = menu.addAction(QIcon(":/res/icons/non-starred-symbolic.svg"),  tr("Remove from favorites"));

-    const int row = index.row();
-    connect(playNow, &QAction::triggered, this, [this, id, row] {
-        m_queue->setContext(m_model->currentTracksJson(), row);
+    const bool isFav = m_model->isFav(id);
+    if (isFav) {
+        auto *remFav = menu.addAction(QIcon(":/res/icons/non-starred-symbolic.svg"), tr("Remove from favorites"));
+        connect(remFav, &QAction::triggered, this, [this, id] {
+            m_backend->removeFavTrack(id);
+            m_model->removeFavId(id);
+        });
+    } else {
+        auto *addFav = menu.addAction(QIcon(":/res/icons/starred-symbolic.svg"), tr("Add to favorites"));
+        connect(addFav, &QAction::triggered, this, [this, id] {
+            m_backend->addFavTrack(id);
+            m_model->addFavId(id);
+        });
+    }
+
+    // Compute filtered row for multi-disc albums (disc headers excluded from currentTracksJson)
+    int filteredRow = 0;
+    for (int r = 0; r < index.row(); ++r)
+        if (!m_model->trackAt(r).isDiscHeader) ++filteredRow;
+    connect(playNow, &QAction::triggered, this, [this, id, filteredRow] {
+        m_queue->setContext(m_model->currentTracksJson(), filteredRow);
        emit playTrackRequested(id);
    });
    connect(playNext, &QAction::triggered, this, [this, trackJson] {
@@ -133,12 +301,6 @@ void Tracks::onContextMenu(const QPoint &pos)
    connect(addQueue, &QAction::triggered, this, [this, trackJson] {
        m_queue->addToQueue(trackJson);
    });
-    connect(addFav, &QAction::triggered, this, [this, id] {
-        m_backend->addFavTrack(id);
-    });
-    connect(remFav, &QAction::triggered, this, [this, id] {
-        m_backend->removeFavTrack(id);
-    });

    // Open album
    const QString albumId = m_model->trackAt(index.row()).albumId;
@@ -146,7 +308,7 @@ void Tracks::onContextMenu(const QPoint &pos)
        menu.addSeparator();
        auto *openAlbum = menu.addAction(
            QIcon(":/res/icons/view-media-album-cover.svg"),
-            tr("Open album: %1").arg(m_model->trackAt(index.row()).album));
+            tr("Open album: %1").arg(QString(m_model->trackAt(index.row()).album).replace(QLatin1Char('&'), QStringLiteral("&&"))));
        connect(openAlbum, &QAction::triggered, this, [this, albumId] {
            m_backend->getAlbum(albumId);
        });
@@ -159,7 +321,7 @@ void Tracks::onContextMenu(const QPoint &pos)
        const QString artistName = trackJson["performer"].toObject()["name"].toString();
        auto *openArtist = menu.addAction(
            QIcon(":/res/icons/view-media-artist.svg"),
-            tr("Open artist: %1").arg(artistName));
+            tr("Open artist: %1").arg(QString(artistName).replace(QLatin1Char('&'), QStringLiteral("&&"))));
        connect(openArtist, &QAction::triggered, this, [this, artistId] {
            m_backend->getArtist(artistId);
        });
@@ -173,7 +335,7 @@ void Tracks::onContextMenu(const QPoint &pos)
        for (const auto &pl : m_userPlaylists) {
            const qint64  plId   = pl.first;
            const QString plName = pl.second;
-            auto *act = addToPlMenu->addAction(plName);
+            auto *act = addToPlMenu->addAction(QString(plName).replace(QLatin1Char('&'), QStringLiteral("&&")));
            connect(act, &QAction::triggered, this, [this, id, plId] {
                emit addToPlaylistRequested(id, plId);
            });
@@ -195,6 +357,13 @@ void Tracks::onContextMenu(const QPoint &pos)
        }
    }

+    // Track info
+    menu.addSeparator();
+    auto *infoAction = menu.addAction(tr("Track info..."));
+    connect(infoAction, &QAction::triggered, this, [this, trackJson] {
+        TrackInfoDialog::show(trackJson, this);
+    });
+
    menu.exec(viewport()->mapToGlobal(pos));
 }

--- a/src/list/tracks.hpp
+++ b/src/list/tracks.hpp
@@ -10,6 +10,7 @@
 #include <QVector>
 #include <QPair>
 #include <QString>
+#include <QSet>

 namespace List
 {
@@ -23,11 +24,17 @@ namespace List
        void loadTracks(const QJsonArray &tracks);
        void loadAlbum(const QJsonObject &album);
        void loadPlaylist(const QJsonObject &playlist);
+        void appendPlaylistPage(const QJsonObject &playlist);
        void loadSearchTracks(const QJsonArray &tracks);

        /// Called when the backend fires EV_TRACK_CHANGED so the playing row is highlighted.
        void setPlayingTrackId(qint64 id);

+        /// Populate favorite track IDs so the star indicator and context menu reflect fav status.
+        void setFavTrackIds(const QSet<qint64> &ids);
+        void addFavTrackId(qint64 id);
+        void removeFavTrackId(qint64 id);
+
        /// Start playing all tracks in the current view from the beginning.
        /// If shuffle is true, enables shuffle mode before starting.
        void playAll(bool shuffle = false);
@@ -49,9 +56,16 @@ namespace List
        QobuzBackend   *m_backend = nullptr;
        PlayQueue      *m_queue   = nullptr;
        qint64          m_playlistId = 0;
+        int             m_playlistTrackTotal = 0;
+        int             m_playlistLoadedCount = 0;
        bool            m_playlistIsOwned = false;
+        bool            m_playlistLoadingMore = false;
+        bool            m_pendingPlayAll = false;
+        bool            m_pendingPlayAllShuffle = false;
        QVector<QPair<qint64, QString>> m_userPlaylists;

+        void maybeLoadMorePlaylistTracks();
+
        void onDoubleClicked(const QModelIndex &index);
        void onContextMenu(const QPoint &pos);
    };
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -4,6 +4,10 @@
 #include "util/settings.hpp"
 #include "util/icon.hpp"

+#ifdef USE_DBUS
+#include "backend/mpris.hpp"
+#endif
+
 #include <QApplication>
 #include <QMenuBar>
 #include <QMenu>
@@ -40,7 +44,7 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
    m_libraryDock->setObjectName(QStringLiteral("libraryDock"));
    m_libraryDock->setFeatures(QDockWidget::DockWidgetMovable);
    m_libraryDock->setWidget(m_library);
-    m_libraryDock->setMinimumWidth(200);
+    m_libraryDock->setMinimumWidth(150);
    addDockWidget(Qt::LeftDockWidgetArea, m_libraryDock);

    // ---- Now-playing context dock (left, below library) ----
@@ -53,7 +57,7 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
    addDockWidget(Qt::RightDockWidgetArea, m_queuePanel);

    // ---- Search side panel (right) ----
-    m_sidePanel = new SidePanel::View(m_backend, this);
+    m_sidePanel = new SidePanel::View(m_backend, m_queue, this);
    m_sidePanel->hide();
    addDockWidget(Qt::RightDockWidgetArea, m_sidePanel);

@@ -69,14 +73,49 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
        connect(m_backend, &QobuzBackend::trackFinished,
                m_scrobbler, &LastFmScrobbler::onTrackFinished);

+        // 1. Scrobble the finished track during a gapless transition
+        connect(m_backend, &QobuzBackend::trackTransitioned,
+                m_scrobbler, &LastFmScrobbler::onTrackFinished);
+
+    // ---- Gapless Signal ----
+        connect(m_backend, &QobuzBackend::positionChanged, this, [this](quint64 pos, quint64 dur) {
+            if (!AppSettings::instance().gaplessEnabled() || dur == 0) return;
+
+            // Trigger prefetch if we pass the 50% mark OR are within 60 seconds of the end
+            if ((pos > dur / 2) || (dur > 60 && (dur - pos) <= 60)) {
+                if (!m_nextTrackPrefetched && m_queue->canGoNext()) {
+                    m_nextTrackPrefetched = true; // Lock it so it only fires once
+
+                    const auto upcoming = m_queue->upcomingTracks(1);
+                    if (!upcoming.isEmpty()) {
+                        const qint64 nextId = static_cast<qint64>(upcoming.first()["id"].toDouble());
+                        if (nextId > 0) {
+                            m_backend->prefetchTrack(nextId, AppSettings::instance().preferredFormat());
+                        }
+                    }
+                }
+            }
+        });
+
    // ---- Backend signals ----
    connect(m_backend, &QobuzBackend::loginSuccess,   this, &MainWindow::onLoginSuccess);
    connect(m_backend, &QobuzBackend::loginError,     this, &MainWindow::onLoginError);
+    connect(m_backend, &QobuzBackend::userLoaded, this, [this](const QJsonObject &user) {
+        const qint64 id = static_cast<qint64>(user["id"].toDouble());
+        if (id > 0) {
+            AppSettings::instance().setUserId(id);
+            m_library->refresh();  // re-load playlists with correct ownership now
+        }
+    });
    connect(m_backend, &QobuzBackend::favTracksLoaded,  this, &MainWindow::onFavTracksLoaded);
    connect(m_backend, &QobuzBackend::favAlbumsLoaded,  this, &MainWindow::onFavAlbumsLoaded);
    connect(m_backend, &QobuzBackend::favArtistsLoaded, this, &MainWindow::onFavArtistsLoaded);
    connect(m_backend, &QobuzBackend::albumLoaded,      this, &MainWindow::onAlbumLoaded);
    connect(m_backend, &QobuzBackend::artistLoaded,     this, &MainWindow::onArtistLoaded);
+    connect(m_backend, &QobuzBackend::artistReleasesLoaded,
+            m_content, &MainContent::updateArtistReleases);
+    connect(m_backend, &QobuzBackend::deepShuffleTracksLoaded,
+            m_content, &MainContent::onDeepShuffleTracks);
    connect(m_backend, &QobuzBackend::playlistLoaded,   this, &MainWindow::onPlaylistLoaded);
    connect(m_backend, &QobuzBackend::playlistCreated,   this, &MainWindow::onPlaylistCreated);
    connect(m_backend, &QobuzBackend::playlistDeleted,   this, [this](const QJsonObject &) {
@@ -88,12 +127,33 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
            m_backend->getPlaylist(playlistId);
        statusBar()->showMessage(tr("Track added to playlist"), 3000);
    });
+    connect(m_backend, &QobuzBackend::playlistSubscribed, this, [this](qint64 playlistId) {
+        m_userPlaylistIds.insert(playlistId);
+        m_library->refresh();
+        if (m_content->tracksList()->playlistId() == playlistId)
+            m_content->setCurrentPlaylistFollowed(true);
+        statusBar()->showMessage(tr("Playlist followed"), 3000);
+    });
+    connect(m_backend, &QobuzBackend::playlistUnsubscribed, this, [this](qint64 playlistId) {
+        m_userPlaylistIds.remove(playlistId);
+        m_library->refresh();
+        if (m_content->tracksList()->playlistId() == playlistId)
+            m_content->setCurrentPlaylistFollowed(false);
+        statusBar()->showMessage(tr("Playlist unfollowed"), 3000);
+    });
    connect(m_backend, &QobuzBackend::trackChanged,   this, &MainWindow::onTrackChanged);
    connect(m_backend, &QobuzBackend::error, this, [this](const QString &msg) {
        statusBar()->showMessage(tr("Error: %1").arg(msg), 6000);
    });

    // ---- Library signals ----
+    connect(m_library, &List::Library::userPlaylistIdsChanged,
+            this, [this](const QSet<qint64> &playlistIds) {
+        m_userPlaylistIds = playlistIds;
+        const qint64 currentPlaylistId = m_content->tracksList()->playlistId();
+        if (currentPlaylistId > 0)
+            m_content->setCurrentPlaylistFollowed(m_userPlaylistIds.contains(currentPlaylistId));
+    });
    connect(m_library, &List::Library::userPlaylistsChanged,
            this, &MainWindow::onUserPlaylistsChanged);
    connect(m_library, &List::Library::openPlaylistDeleted,
@@ -107,11 +167,59 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
        m_backend->getFavTracks();
        statusBar()->showMessage(tr("Loading favorite tracks…"));
    });
+
+#ifdef USE_DBUS
+    m_mpris = new Mpris(this);
+    connect(m_mpris->player(), &MprisPlayerAdaptor::playRequested, m_backend, [this] {
+        if (m_backend->state() == 2) m_backend->resume();
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::pauseRequested, m_backend, &QobuzBackend::pause);
+    connect(m_mpris->player(), &MprisPlayerAdaptor::playPauseRequested, m_backend, [this] {
+        if (m_backend->state() == 1)
+            m_backend->pause();
+        else
+            m_backend->resume();
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::stopRequested, m_backend, &QobuzBackend::stop);
+    connect(m_mpris->player(), &MprisPlayerAdaptor::nextRequested, this, [this] {
+        if (!m_queue->canGoNext()) return;
+        const qint64 id = static_cast<qint64>(m_queue->advance()["id"].toDouble());
+        if (id > 0) m_backend->playTrack(id);
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::previousRequested, this, [this] {
+        if (!m_queue->canGoPrev()) return;
+        const qint64 id = static_cast<qint64>(m_queue->stepBack()["id"].toDouble());
+        if (id > 0) m_backend->playTrack(id);
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::seekRequested, m_backend, [this](qlonglong offsetMicroseconds) {
+        qint64 newPos = m_backend->position() + (offsetMicroseconds / 1000000LL);
+        if (newPos < 0) newPos = 0;
+        m_backend->seek(newPos);
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::seekToRequested, m_backend, [this](qlonglong positionMicroseconds) {
+        m_backend->seek(positionMicroseconds / 1000000LL);
+    });
+    connect(m_mpris->player(), &MprisPlayerAdaptor::volumeChangeRequested, m_backend, [this](double vol) {
+        m_backend->setVolume(vol * 100);
+    });
+
+    connect(m_backend, &QobuzBackend::stateChanged, this, [this](const QString &state) {
+        if (state == "playing") m_mpris->player()->setPlaybackStatus("Playing");
+        else if (state == "paused") m_mpris->player()->setPlaybackStatus("Paused");
+        else m_mpris->player()->setPlaybackStatus("Stopped");
+    });
+    connect(m_backend, &QobuzBackend::positionChanged, this, [this](quint64 pos) {
+        m_mpris->player()->updatePosition(pos);
+    });
+#endif
+
    connect(m_library, &List::Library::favAlbumsRequested, this, [this] {
+        m_showFavAlbumsOnLoad = true;
        m_backend->getFavAlbums();
        statusBar()->showMessage(tr("Loading favorite albums…"));
    });
    connect(m_library, &List::Library::favArtistsRequested, this, [this] {
+        m_showFavArtistsOnLoad = true;
        m_backend->getFavArtists();
        statusBar()->showMessage(tr("Loading favorite artists…"));
    });
@@ -120,6 +228,14 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
        m_backend->getPlaylist(id);
        statusBar()->showMessage(tr("Loading playlist: %1…").arg(name));
    });
+    connect(m_library, &List::Library::browseGenresRequested, this, [this] {
+        m_content->showGenreBrowser();
+        statusBar()->showMessage(tr("Browse Genres"));
+    });
+    connect(m_library, &List::Library::browsePlaylistsRequested, this, [this] {
+        m_content->showPlaylistBrowser();
+        statusBar()->showMessage(tr("Browse Playlists"));
+    });

    // ---- Track list → playback / playlist management ----
    connect(m_content->tracksList(), &List::Tracks::playTrackRequested,
@@ -142,12 +258,44 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
            this, &MainWindow::onSearchArtistSelected);
    connect(m_sidePanel, &SidePanel::View::trackPlayRequested,
            this, &MainWindow::onPlayTrackRequested);
+    connect(m_sidePanel, &SidePanel::View::addToPlaylistRequested,
+            this, [this](qint64 trackId, qint64 playlistId) {
+        m_backend->addTrackToPlaylist(playlistId, trackId);
+        statusBar()->showMessage(tr("Adding track to playlist..."), 3000);
+    });

    // ---- Album / artist navigation from content views ----
    connect(m_content, &MainContent::albumRequested,
            this, &MainWindow::onSearchAlbumSelected);
    connect(m_content, &MainContent::artistRequested,
            this, &MainWindow::onSearchArtistSelected);
+    connect(m_content, &MainContent::albumFavoriteToggled,
+            this, [this](const QString &albumId, bool favorite) {
+        if (favorite) {
+            m_backend->addFavAlbum(albumId);
+            m_favAlbumIds.insert(albumId);
+            statusBar()->showMessage(tr("Added album to favorites"), 3000);
+        } else {
+            m_backend->removeFavAlbum(albumId);
+            m_favAlbumIds.remove(albumId);
+            statusBar()->showMessage(tr("Removed album from favorites"), 3000);
+        }
+        m_content->setFavAlbumIds(m_favAlbumIds);
+    });
+    connect(m_content, &MainContent::playlistRequested,
+            this, [this](qint64 playlistId) {
+        m_backend->getPlaylist(playlistId);
+        statusBar()->showMessage(tr("Loading playlist…"));
+    });
+    connect(m_content, &MainContent::playlistFollowToggled,
+            this, [this](qint64 playlistId, bool follow) {
+        if (follow)
+            m_backend->subscribePlaylist(playlistId);
+        else
+            m_backend->unsubscribePlaylist(playlistId);
+    });
+    connect(m_content, &MainContent::playTrackRequested,
+            this, &MainWindow::onPlayTrackRequested);

    // ---- Queue panel ----
    connect(m_queuePanel, &QueuePanel::skipToTrackRequested,
@@ -157,6 +305,15 @@ MainWindow::MainWindow(QobuzBackend *backend, QWidget *parent)
    connect(m_toolBar, &MainToolBar::searchToggled, this, &MainWindow::onSearchToggled);
    connect(m_toolBar, &MainToolBar::queueToggled,
            this, [this](bool v) { m_queuePanel->setVisible(v); });
+    connect(m_queuePanel, &QDockWidget::visibilityChanged,
+            m_toolBar, &MainToolBar::setQueueToggleChecked);
+    connect(m_sidePanel, &QDockWidget::visibilityChanged,
+            m_toolBar, &MainToolBar::setSearchToggleChecked);
+    m_toolBar->setQueueToggleChecked(m_queuePanel->isVisible());
+    m_toolBar->setSearchToggleChecked(m_sidePanel->isVisible());
+
+    connect(m_toolBar, &MainToolBar::albumRequested,  this, &MainWindow::onSearchAlbumSelected);
+    connect(m_toolBar, &MainToolBar::artistRequested, this, &MainWindow::onSearchArtistSelected);

    // Apply playback options from saved settings
    m_backend->setReplayGain(AppSettings::instance().replayGainEnabled());
@@ -199,7 +356,14 @@ void MainWindow::tryRestoreSession()
    const QString token = AppSettings::instance().authToken();
    if (!token.isEmpty()) {
        m_backend->setToken(token);
+        if (AppSettings::instance().userId() == 0)
+            m_backend->getUser();  // userLoaded will call m_library->refresh()
+        else
            m_library->refresh();
+        // Preload fav albums so the album page fav button is accurate immediately.
+        m_backend->getFavAlbums();
+        // Preload fav artists so the artist page fav button works immediately
+        m_backend->getFavArtists();
        const QString name = AppSettings::instance().displayName();
        statusBar()->showMessage(tr("Signed in as %1").arg(
            name.isEmpty() ? AppSettings::instance().userEmail() : name));
@@ -249,6 +413,8 @@ void MainWindow::onLoginSuccess(const QString &token, const QJsonObject &user)
    statusBar()->showMessage(tr("Signed in as %1").arg(
        displayName.isEmpty() ? email : displayName));
    m_library->refresh();
+    m_backend->getFavAlbums();
+    m_backend->getFavArtists();
 }

 void MainWindow::onLoginError(const QString &error)
@@ -258,6 +424,7 @@ void MainWindow::onLoginError(const QString &error)

 void MainWindow::onTrackChanged(const QJsonObject &track)
 {
+    m_nextTrackPrefetched = false;
    // Update playing row highlight in the track list
    const qint64 id = static_cast<qint64>(track["id"].toDouble());
    m_content->tracksList()->setPlayingTrackId(id);
@@ -270,19 +437,38 @@ void MainWindow::onTrackChanged(const QJsonObject &track)
    statusBar()->showMessage(
        artist.isEmpty() ? title : QStringLiteral("▶  %1 — %2").arg(artist, title));

-    // Prefetch next track URL when gapless is enabled
-    if (AppSettings::instance().gaplessEnabled() && m_queue->canGoNext()) {
-        const auto upcoming = m_queue->upcomingTracks(1);
-        if (!upcoming.isEmpty()) {
-            const qint64 nextId = static_cast<qint64>(upcoming.first()["id"].toDouble());
-            if (nextId > 0)
-                m_backend->prefetchTrack(nextId, AppSettings::instance().preferredFormat());
+#ifdef USE_DBUS
+    QVariantMap metadata;
+    metadata["mpris:trackid"] = QVariant::fromValue(QDBusObjectPath(QString("/org/qobuz/track/%1").arg(id)));
+    metadata["mpris:length"] = QVariant::fromValue(qlonglong(track["duration"].toDouble() * 1000000LL));
+    metadata["xesam:title"]  = title;
+
+    QJsonObject album = track["album"].toObject();
+    metadata["xesam:album"]  = album["title"].toString();
+
+    if (!artist.isEmpty()) {
+        metadata["xesam:artist"] = QStringList{artist};
    }
+
+    if (album.contains("image") && album["image"].toObject().contains("large")) {
+        metadata["mpris:artUrl"] = album["image"].toObject()["large"].toString();
    }
+
+    m_mpris->player()->setMetadata(metadata);
+#endif
 }

 void MainWindow::onFavTracksLoaded(const QJsonObject &result)
 {
+    // Cache fav IDs so the star indicator and context menu stay in sync
+    QSet<qint64> ids;
+    const QJsonArray items = result["items"].toArray();
+    for (const QJsonValue &v : items) {
+        const qint64 id = static_cast<qint64>(v.toObject()["id"].toDouble());
+        if (id > 0) ids.insert(id);
+    }
+    m_content->tracksList()->setFavTrackIds(ids);
+
    m_content->showFavTracks(result);
    statusBar()->showMessage(
        tr("%1 favorite tracks").arg(result["total"].toInt()), 4000);
@@ -290,17 +476,47 @@ void MainWindow::onFavTracksLoaded(const QJsonObject &result)

 void MainWindow::onFavAlbumsLoaded(const QJsonObject &result)
 {
+    // Always cache fav album IDs (needed by the album page fav button)
+    m_favAlbumIds.clear();
+    const QJsonArray items = result["items"].toArray();
+    for (const QJsonValue &v : items) {
+        const QJsonObject album = v.toObject();
+        QString id = album["id"].toString();
+        if (id.isEmpty() && album["id"].isDouble())
+            id = QString::number(static_cast<qint64>(album["id"].toDouble()));
+        if (!id.isEmpty())
+            m_favAlbumIds.insert(id);
+    }
+    m_content->setFavAlbumIds(m_favAlbumIds);
+
+    // Only navigate to the fav albums page if the user explicitly requested it
+    if (m_showFavAlbumsOnLoad) {
+        m_showFavAlbumsOnLoad = false;
        m_content->showFavAlbums(result);
        statusBar()->showMessage(
            tr("%1 favorite albums").arg(result["total"].toInt()), 4000);
    }
+}

 void MainWindow::onFavArtistsLoaded(const QJsonObject &result)
 {
+    // Always cache fav artist IDs (needed by the artist page fav button)
+    m_favArtistIds.clear();
+    const QJsonArray items = result["items"].toArray();
+    for (const QJsonValue &v : items) {
+        const qint64 id = static_cast<qint64>(v.toObject()["id"].toDouble());
+        if (id > 0) m_favArtistIds.insert(id);
+    }
+    m_content->setFavArtistIds(m_favArtistIds);
+
+    // Only navigate to the fav artists page if the user explicitly requested it
+    if (m_showFavArtistsOnLoad) {
+        m_showFavArtistsOnLoad = false;
        m_content->showFavArtists(result);
        statusBar()->showMessage(
            tr("%1 favorite artists").arg(result["total"].toInt()), 4000);
    }
+}

 void MainWindow::onAlbumLoaded(const QJsonObject &album)
 {
@@ -312,13 +528,39 @@ void MainWindow::onAlbumLoaded(const QJsonObject &album)
 void MainWindow::onArtistLoaded(const QJsonObject &artist)
 {
    m_content->showArtist(artist);
+    // Fire release requests only after the artist page is shown — avoids the
+    // race where a fast-responding release request arrives before setArtist()
+    // clears the sections, causing setArtist() to wipe out the data.
+    const qint64 artistId = static_cast<qint64>(artist["id"].toDouble());
+    for (const char *type : {"album", "epSingle", "live", "compilation"})
+        m_backend->getArtistReleases(artistId, QString::fromLatin1(type));
    statusBar()->showMessage(
-        tr("Artist: %1").arg(artist["name"].toString()), 4000);
+        tr("Artist: %1").arg(artist["name"].toObject()["display"].toString()), 4000);
 }

 void MainWindow::onPlaylistLoaded(const QJsonObject &playlist)
 {
-    m_content->showPlaylist(playlist);
+    const bool fullLoad = playlist["full_load"].toBool(false);
+    const int trackOffset = playlist["tracks"].toObject()["offset"].toInt(0);
+    if (!fullLoad && trackOffset > 0) {
+        m_content->tracksList()->appendPlaylistPage(playlist);
+        return;
+    }
+
+    const qint64 id = static_cast<qint64>(playlist["id"].toDouble());
+    const qint64 ownerId = static_cast<qint64>(playlist["owner"].toObject()["id"].toDouble());
+    const qint64 myId = AppSettings::instance().userId();
+    const bool isOwned = (myId > 0 && ownerId == myId);
+
+    bool isFollowed = isOwned || m_userPlaylistIds.contains(id);
+    if (!isFollowed) {
+        if (playlist.contains("is_subscribed"))
+            isFollowed = playlist["is_subscribed"].toBool();
+        else if (playlist.contains("subscribed_at"))
+            isFollowed = !playlist["subscribed_at"].isNull();
+    }
+
+    m_content->showPlaylist(playlist, isFollowed, isOwned);
    statusBar()->showMessage(
        tr("Playlist: %1").arg(playlist["name"].toString()), 4000);
 }
@@ -359,4 +601,5 @@ void MainWindow::onUserPlaylistsChanged(const QVector<QPair<qint64, QString>> &p
 {
    m_userPlaylists = playlists;
    m_content->tracksList()->setUserPlaylists(playlists);
+    m_sidePanel->searchTab()->setUserPlaylists(playlists);
 }
--- a/src/mainwindow.hpp
+++ b/src/mainwindow.hpp
@@ -13,10 +13,14 @@
 #include <QMainWindow>
 #include <QDockWidget>
 #include <QJsonObject>
+#include <QJsonArray>
 #include <QVector>
+#include <QSet>
 #include <QPair>
 #include <QString>

+class Mpris;
+
 class MainWindow : public QMainWindow
 {
    Q_OBJECT
@@ -51,6 +55,11 @@ private:
    QobuzBackend    *m_backend     = nullptr;
    PlayQueue       *m_queue       = nullptr;
    QVector<QPair<qint64, QString>> m_userPlaylists;
+    QSet<qint64> m_userPlaylistIds;
+    QSet<QString> m_favAlbumIds;
+    QSet<qint64> m_favArtistIds;
+    bool m_showFavAlbumsOnLoad = false;
+    bool m_showFavArtistsOnLoad = false;
    MainToolBar     *m_toolBar     = nullptr;
    MainContent     *m_content     = nullptr;
    List::Library   *m_library     = nullptr;
@@ -59,6 +68,8 @@ private:
    SidePanel::View *m_sidePanel   = nullptr;
    QDockWidget     *m_libraryDock = nullptr;
    LastFmScrobbler *m_scrobbler   = nullptr;
+    Mpris           *m_mpris       = nullptr;
+    bool m_nextTrackPrefetched = false;

    void setupMenuBar();
    void tryRestoreSession();
--- a/src/model/tracklistmodel.cpp
+++ b/src/model/tracklistmodel.cpp
@@ -9,26 +9,26 @@ TrackListModel::TrackListModel(QObject *parent)
    : QAbstractTableModel(parent)
 {}

-void TrackListModel::setTracks(const QJsonArray &tracks,
+TrackItem TrackListModel::parseTrackItem(const QJsonObject &t,
                                         bool usePosition,
-                               bool useSequential)
+                                         bool useSequential,
+                                         int &seq)
 {
-    beginResetModel();
-    m_tracks.clear();
-    m_tracks.reserve(tracks.size());
-
-    int seq = 1;
-    for (const QJsonValue &v : tracks) {
-        const QJsonObject t = v.toObject();
    TrackItem item;
    item.id               = static_cast<qint64>(t["id"].toDouble());
    item.playlistTrackId  = static_cast<qint64>(t["playlist_track_id"].toDouble());
-        item.title            = t["title"].toString();
+    item.discNumber       = t["media_number"].toInt(1);
    item.duration         = static_cast<qint64>(t["duration"].toDouble());
-        item.hiRes      = t["hires_streamable"].toBool();
    item.streamable       = t["streamable"].toBool(true);
+    item.hiRes            = t["hires_streamable"].toBool();
    item.raw              = t;

+    // Combine title + version ("Melody" + "Vocal Remix" → "Melody (Vocal Remix)")
+    const QString base    = t["title"].toString();
+    const QString version = t["version"].toString().trimmed();
+    item.title = version.isEmpty() ? base
+               : base + QStringLiteral(" (") + version + QLatin1Char(')');
+
    if (useSequential) {
        item.number = seq++;
    } else if (usePosition) {
@@ -41,27 +41,125 @@ void TrackListModel::setTracks(const QJsonArray &tracks,

    const QJsonObject performer = t["performer"].toObject();
    item.artist = performer["name"].toString();
-        if (item.artist.isEmpty())
-            item.artist = t["album"].toObject()["artist"].toObject()["name"].toString();
+    if (item.artist.isEmpty()) {
+        // album.artist.name may be a plain string or {display:"..."} object
+        const QJsonValue n = t["album"].toObject()["artist"].toObject()["name"];
+        item.artist = n.isObject() ? n.toObject()["display"].toString() : n.toString();
+    }
+    if (item.artist.isEmpty()) {
+        // top_tracks format: artist.name.display
+        const QJsonValue n = t["artist"].toObject()["name"];
+        item.artist = n.isObject() ? n.toObject()["display"].toString() : n.toString();
+    }

    const QJsonObject album = t["album"].toObject();
    item.album   = album["title"].toString();
    item.albumId = album["id"].toString();

-        m_tracks.append(item);
+    return item;
 }

-    // Re-apply sort silently inside the reset (no layout signals needed here)
+void TrackListModel::setTracks(const QJsonArray &tracks,
+                               bool usePosition,
+                               bool useSequential)
+{
+    beginResetModel();
+    m_tracks.clear();
+    m_tracks.reserve(tracks.size());
+
+    // Parse into a temporary list first so we can detect multi-disc
+    QVector<TrackItem> parsed;
+    parsed.reserve(tracks.size());
+
+    int seq = 1;
+    for (const QJsonValue &v : tracks)
+        parsed.append(parseTrackItem(v.toObject(), usePosition, useSequential, seq));
+
+    // Multi-disc only makes sense for album context (not playlists / fav / search)
+    int maxDisc = 1;
+    if (!usePosition && !useSequential) {
+        for (const TrackItem &t : parsed)
+            maxDisc = qMax(maxDisc, t.discNumber);
+    }
+    m_hasMultipleDiscs = (maxDisc > 1);
+
+    if (m_hasMultipleDiscs) {
+        // Sort by disc then track number
+        std::stable_sort(parsed.begin(), parsed.end(), [](const TrackItem &a, const TrackItem &b) {
+            return a.discNumber != b.discNumber ? a.discNumber < b.discNumber
+                                               : a.number < b.number;
+        });
+        // Interleave disc header items
+        int currentDisc = -1;
+        for (const TrackItem &t : parsed) {
+            if (t.discNumber != currentDisc) {
+                TrackItem header;
+                header.isDiscHeader = true;
+                header.discNumber   = t.discNumber;
+                header.title        = tr("Disc %1").arg(t.discNumber);
+                m_tracks.append(header);
+                currentDisc = t.discNumber;
+            }
+            m_tracks.append(t);
+        }
+    } else {
+        m_tracks = parsed;
+        // Re-apply sort silently inside the reset
        if (m_sortColumn >= 0)
            sortData(m_sortColumn, m_sortOrder);
+    }

    endResetModel();

-    // Tell external listeners the sorted order is ready (e.g. PlayQueue sync)
-    if (m_sortColumn >= 0)
+    if (!m_hasMultipleDiscs && m_sortColumn >= 0)
        emit sortApplied();
 }

+void TrackListModel::appendTracks(const QJsonArray &tracks,
+                                  bool usePosition,
+                                  bool useSequential)
+{
+    if (tracks.isEmpty())
+        return;
+
+    // Keep append path simple and stable: disc-header mode is handled by reset path.
+    if (m_hasMultipleDiscs && !usePosition && !useSequential) {
+        QJsonArray all = currentTracksJson();
+        for (const QJsonValue &v : tracks)
+            all.append(v);
+        setTracks(all, usePosition, useSequential);
+        return;
+    }
+
+    int seq = 1;
+    if (useSequential || usePosition) {
+        for (const TrackItem &t : m_tracks)
+            if (!t.isDiscHeader)
+                ++seq;
+    }
+
+    QVector<TrackItem> parsed;
+    parsed.reserve(tracks.size());
+    for (const QJsonValue &v : tracks)
+        parsed.append(parseTrackItem(v.toObject(), usePosition, useSequential, seq));
+
+    if (parsed.isEmpty())
+        return;
+
+    const int first = m_tracks.size();
+    const int last  = first + parsed.size() - 1;
+    beginInsertRows({}, first, last);
+    m_tracks += parsed;
+    endInsertRows();
+
+    if (!m_hasMultipleDiscs && m_sortColumn >= 0) {
+        emit layoutAboutToBeChanged();
+        sortData(m_sortColumn, m_sortOrder);
+        emit layoutChanged();
+        emit sortApplied();
+    }
+}
+
 void TrackListModel::clear()
 {
    beginResetModel();
@@ -77,6 +175,36 @@ void TrackListModel::removeTrack(int row)
    endRemoveRows();
 }

+void TrackListModel::notifyFavChanged(qint64 id)
+{
+    for (int r = 0; r < m_tracks.size(); ++r) {
+        if (m_tracks[r].id == id) {
+            const auto idx = index(r, ColTitle);
+            emit dataChanged(idx, idx, {Qt::DecorationRole});
+        }
+    }
+}
+
+void TrackListModel::setFavIds(const QSet<qint64> &ids)
+{
+    m_favIds = ids;
+    if (!m_tracks.isEmpty())
+        emit dataChanged(index(0, ColTitle), index(rowCount() - 1, ColTitle),
+                         {Qt::DecorationRole});
+}
+
+void TrackListModel::addFavId(qint64 id)
+{
+    m_favIds.insert(id);
+    notifyFavChanged(id);
+}
+
+void TrackListModel::removeFavId(qint64 id)
+{
+    m_favIds.remove(id);
+    notifyFavChanged(id);
+}
+
 void TrackListModel::setPlayingId(qint64 id)
 {
    m_playingId = id;
@@ -85,6 +213,23 @@ void TrackListModel::setPlayingId(qint64 id)
                         {Qt::FontRole, Qt::DecorationRole});
 }

+Qt::ItemFlags TrackListModel::flags(const QModelIndex &index) const
+{
+    if (!index.isValid() || index.row() >= m_tracks.size())
+        return Qt::NoItemFlags;
+    if (m_tracks.at(index.row()).isDiscHeader)
+        return Qt::ItemIsEnabled;
+    return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
+}
+
+QVector<int> TrackListModel::discHeaderRows() const
+{
+    QVector<int> rows;
+    for (int i = 0; i < m_tracks.size(); ++i)
+        if (m_tracks[i].isDiscHeader) rows.append(i);
+    return rows;
+}
+
 int TrackListModel::rowCount(const QModelIndex &parent) const
 {
    return parent.isValid() ? 0 : m_tracks.size();
@@ -101,6 +246,19 @@ QVariant TrackListModel::data(const QModelIndex &index, int role) const
        return {};

    const TrackItem &t = m_tracks.at(index.row());
+
+    // Disc header rows: styled separator spanning all columns via setFirstColumnSpanned
+    if (t.isDiscHeader) {
+        if (role == Qt::DisplayRole && index.column() == ColNumber)
+            return t.title;
+        if (role == Qt::FontRole) {
+            QFont f; f.setBold(true); return f;
+        }
+        if (role == Qt::ForegroundRole)
+            return QColor(0xFF, 0xB2, 0x32);
+        return {};
+    }
+
    const bool isPlaying = (t.id == m_playingId && m_playingId != 0);

    if (role == Qt::DisplayRole) {
@@ -128,6 +286,10 @@ QVariant TrackListModel::data(const QModelIndex &index, int role) const
        return QIcon(QStringLiteral(":/res/icons/media-track-show-active.svg"));
    }

+    if (role == Qt::DecorationRole && index.column() == ColTitle && m_favIds.contains(t.id)) {
+        return QIcon(QStringLiteral(":/res/icons/starred-symbolic.svg"));
+    }
+
    if (role == TrackIdRole)         return t.id;
    if (role == TrackJsonRole)       return t.raw;
    if (role == HiResRole)           return t.hiRes;
@@ -179,7 +341,8 @@ void TrackListModel::sort(int column, Qt::SortOrder order)
    m_sortColumn = column;
    m_sortOrder  = order;

-    if (m_tracks.isEmpty()) return;
+    // Multi-disc albums keep their disc-ordered layout; don't re-sort
+    if (m_hasMultipleDiscs || m_tracks.isEmpty()) return;

    emit layoutAboutToBeChanged();
    sortData(column, order);
@@ -190,7 +353,8 @@ void TrackListModel::sort(int column, Qt::SortOrder order)

 QString TrackListModel::formatDuration(qint64 secs)
 {
-    const int m = static_cast<int>(secs / 60);
-    const int s = static_cast<int>(secs % 60);
+    if (secs < 0) secs = 0;
+    const qint64 m = secs / 60;
+    const qint64 s = secs % 60;
    return QStringLiteral("%1:%2").arg(m).arg(s, 2, 10, QLatin1Char('0'));
 }
--- a/src/model/tracklistmodel.hpp
+++ b/src/model/tracklistmodel.hpp
@@ -4,12 +4,15 @@
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QVector>
+#include <QSet>
 #include <QFont>

 struct TrackItem {
    qint64  id              = 0;
    qint64  playlistTrackId = 0;
    int     number          = 0;
+    int     discNumber      = 1;
+    bool    isDiscHeader    = false;
    QString title;
    QString artist;
    QString album;
@@ -48,21 +51,34 @@ public:
    void setTracks(const QJsonArray &tracks,
                   bool usePosition   = false,
                   bool useSequential = false);
+    void appendTracks(const QJsonArray &tracks,
+                      bool usePosition   = false,
+                      bool useSequential = false);
    void clear();
    void setPlayingId(qint64 id);
    qint64 playingId() const { return m_playingId; }

+    void setFavIds(const QSet<qint64> &ids);
+    void addFavId(qint64 id);
+    void removeFavId(qint64 id);
+    bool isFav(qint64 id) const { return m_favIds.contains(id); }
+
+    bool hasMultipleDiscs() const { return m_hasMultipleDiscs; }
+    QVector<int> discHeaderRows() const;
+
+    Qt::ItemFlags flags(const QModelIndex &index) const override;
+
    /// Optimistically remove a row (e.g. after deleting from playlist).
    void removeTrack(int row);

    const TrackItem &trackAt(int row) const { return m_tracks.at(row); }

-    // Returns the current (possibly sorted) raw JSON objects in display order.
+    // Returns the current (possibly sorted) raw JSON objects in display order, skipping disc headers.
    QJsonArray currentTracksJson() const
    {
        QJsonArray out;
        for (const auto &t : m_tracks)
-            out.append(t.raw);
+            if (!t.isDiscHeader) out.append(t.raw);
        return out;
    }

@@ -81,10 +97,18 @@ signals:

 private:
    QVector<TrackItem> m_tracks;
+    QSet<qint64>       m_favIds;
    qint64 m_playingId        = 0;
+    bool   m_hasMultipleDiscs = false;
    int    m_sortColumn = -1;
    Qt::SortOrder m_sortOrder = Qt::AscendingOrder;

    // Sort m_tracks in-place without emitting any signals.
    void sortData(int column, Qt::SortOrder order);
+
+    // Parse a single JSON track object into a TrackItem.
+    static TrackItem parseTrackItem(const QJsonObject &t, bool usePosition, bool useSequential, int &seq);
+
+    // Emit dataChanged(DecorationRole) for all rows matching id.
+    void notifyFavChanged(qint64 id);
 };
--- a/src/playqueue.hpp
+++ b/src/playqueue.hpp
@@ -107,6 +107,14 @@ public:
        emit queueChanged();
    }

+    /// Shuffle the current queue once without changing the global shuffle flag.
+    void shuffleNow()
+    {
+        if (m_queue.isEmpty()) return;
+        shuffleQueue(m_index);
+        emit queueChanged();
+    }
+
    // ---- Play-next prepend queue (like "Add to queue" ----

    void addToQueue(const QJsonObject &track)
@@ -233,6 +241,17 @@ public:
        emit queueChanged();
    }

+    /// Append tracks to the main queue tail (autoplay/discovery).
+    void appendToContext(const QJsonArray &tracks)
+    {
+        for (const auto &v : tracks) {
+            const QJsonObject t = v.toObject();
+            if (t["streamable"].toBool(true))
+                m_queue.append(t);
+        }
+        emit queueChanged();
+    }
+
    /// Move an upcoming item (by its index in upcomingTracks()) to the front of playNext.
    void moveUpcomingToTop(int upcomingIndex)
    {
--- a/src/scrobbler/lastfm.hpp
+++ b/src/scrobbler/lastfm.hpp
@@ -80,6 +80,8 @@ public slots:
        m_duration = static_cast<qint64>(track["duration"].toDouble());
        m_startTime       = QDateTime::currentSecsSinceEpoch();
        m_playedSecs      = 0;
+        m_lastPosition    = 0;
+        m_accumulatedSecs = 0;
        m_scrobbled       = false;

        if (!isEnabled() || m_title.isEmpty() || m_duration < 30) return;
@@ -88,18 +90,29 @@ public slots:

    void onPositionChanged(quint64 positionSecs, quint64 /*duration*/)
    {
+        // Accumulate actual listening time to prevent false scrobbles from seeking
+        if (positionSecs > m_lastPosition && (positionSecs - m_lastPosition) <= 2) {
+            m_accumulatedSecs += (positionSecs - m_lastPosition);
+        }
+        m_lastPosition = positionSecs;
        m_playedSecs = positionSecs;
+
        if (!isEnabled() || m_scrobbled || m_title.isEmpty() || m_duration < 30) return;
+
        // Scrobble after 50% or 240 seconds played, whichever comes first, min 30 seconds.
        const quint64 threshold = static_cast<quint64>(qMin((qint64)240, m_duration / 2));
-        if (positionSecs >= 30 && positionSecs >= threshold)
+        if (m_accumulatedSecs >= 30 && m_accumulatedSecs >= threshold)
            scrobble();
    }

    void onTrackFinished()
    {
        if (!isEnabled() || m_scrobbled || m_title.isEmpty() || m_duration < 30) return;
-        if (m_playedSecs >= 30) scrobble();
+
+        const quint64 threshold = static_cast<quint64>(qMin((qint64)240, m_duration / 2));
+        if (m_accumulatedSecs >= 30 && m_accumulatedSecs >= threshold) {
+            scrobble();
+        }
    }

 private:
@@ -111,6 +124,8 @@ private:
    qint64  m_duration        = 0;
    qint64  m_startTime       = 0;
    quint64 m_playedSecs      = 0;
+    quint64 m_lastPosition    = 0;
+    quint64 m_accumulatedSecs = 0;
    bool    m_scrobbled       = false;

    void updateNowPlaying()
@@ -137,11 +152,13 @@ private:
        params["method"]       = QStringLiteral("track.scrobble");
        params["api_key"]      = AppSettings::instance().lastFmApiKey();
        params["sk"]           = AppSettings::instance().lastFmSessionKey();
-        params["artist"]    = m_artist;
-        params["track"]     = m_title;
-        params["album"]     = m_album;
-        params["timestamp"] = QString::number(m_startTime);
-        params["duration"]  = QString::number(m_duration);
+
+        params["artist[0]"]    = m_artist;
+        params["track[0]"]     = m_title;
+        params["album[0]"]     = m_album;
+        params["timestamp[0]"] = QString::number(m_startTime);
+        params["duration[0]"]  = QString::number(m_duration);
+
        params["api_sig"]      = buildSig(params, AppSettings::instance().lastFmApiSecret());
        params["format"]       = QStringLiteral("json");

--- a/src/util/icon.hpp
+++ b/src/util/icon.hpp
@@ -24,6 +24,7 @@ namespace Icon
    inline QIcon previous()   { return get("media-skip-backward"); }
    inline QIcon shuffle()    { return get("media-playlist-shuffle"); }
    inline QIcon repeat()     { return get("media-playlist-repeat"); }
+    inline QIcon autoplay()   { return get("media-track-show-active"); }

    // Volume
    inline QIcon volumeHigh() { return get("audio-volume-high"); }
--- a/src/util/settings.hpp
+++ b/src/util/settings.hpp
@@ -41,6 +41,9 @@ public:
    bool gaplessEnabled() const        { return m_settings.value("playback/gapless", false).toBool(); }
    void setGaplessEnabled(bool v)     { m_settings.setValue("playback/gapless", v); }

+    bool autoplayEnabled() const       { return m_settings.value("playback/autoplay", false).toBool(); }
+    void setAutoplayEnabled(bool v)    { m_settings.setValue("playback/autoplay", v); }
+
    // --- Last.fm ---
    bool    lastFmEnabled()   const  { return m_settings.value("lastfm/enabled", false).toBool(); }
    void    setLastFmEnabled(bool v) { m_settings.setValue("lastfm/enabled", v); }
--- a/src/util/trackinfo.hpp
+++ b/src/util/trackinfo.hpp
@@ -0,0 +1,85 @@
+#pragma once
+
+#include <QDialog>
+#include <QFormLayout>
+#include <QDialogButtonBox>
+#include <QLabel>
+#include <QJsonObject>
+#include <QWidget>
+
+namespace TrackInfoDialog
+{
+
+inline void show(const QJsonObject &track, QWidget *parent)
+{
+    auto *dlg = new QDialog(parent);
+    dlg->setWindowTitle(QObject::tr("Track Info"));
+    dlg->setAttribute(Qt::WA_DeleteOnClose);
+    dlg->setMinimumWidth(360);
+
+    auto *form = new QFormLayout(dlg);
+
+    auto addRow = [&](const QString &label, const QString &value) {
+        if (value.isEmpty()) return;
+        auto *val = new QLabel(value, dlg);
+        val->setTextInteractionFlags(Qt::TextSelectableByMouse);
+        val->setWordWrap(true);
+        form->addRow(QStringLiteral("<b>%1</b>").arg(label), val);
+    };
+
+    const QString title   = track["title"].toString();
+    const QString version = track["version"].toString().trimmed();
+    addRow(QObject::tr("Title"),
+           version.isEmpty() ? title : title + QStringLiteral(" (%1)").arg(version));
+
+    addRow(QObject::tr("Performer"), track["performer"].toObject()["name"].toString());
+
+    const QJsonObject composer = track["composer"].toObject();
+    if (!composer.isEmpty())
+        addRow(QObject::tr("Composer"), composer["name"].toString());
+
+    const QJsonObject album = track["album"].toObject();
+    addRow(QObject::tr("Album"), album["title"].toString());
+    addRow(QObject::tr("Album artist"), album["artist"].toObject()["name"].toString());
+
+    const int trackNum = track["track_number"].toInt();
+    const int discNum  = track["media_number"].toInt();
+    if (trackNum > 0) {
+        const QString pos = discNum > 1
+            ? QStringLiteral("%1-%2").arg(discNum).arg(trackNum)
+            : QString::number(trackNum);
+        addRow(QObject::tr("Track #"), pos);
+    }
+
+    const qint64 dur = static_cast<qint64>(track["duration"].toDouble());
+    if (dur > 0) {
+        const int m = static_cast<int>(dur / 60);
+        const int s = static_cast<int>(dur % 60);
+        addRow(QObject::tr("Duration"),
+               QStringLiteral("%1:%2").arg(m).arg(s, 2, 10, QLatin1Char('0')));
+    }
+
+    const int bitDepth     = track["maximum_bit_depth"].toInt();
+    const double sampleRate = track["maximum_sampling_rate"].toDouble();
+    if (bitDepth > 0 && sampleRate > 0) {
+        addRow(QObject::tr("Quality"),
+               QStringLiteral("%1-bit / %2 kHz").arg(bitDepth).arg(sampleRate, 0, 'f', 1));
+    } else if (bitDepth > 0) {
+        addRow(QObject::tr("Bit depth"), QStringLiteral("%1-bit").arg(bitDepth));
+    }
+
+    const bool hiRes = track["hires_streamable"].toBool() || track["hires"].toBool();
+    addRow(QObject::tr("Hi-Res"), hiRes ? QObject::tr("Yes") : QObject::tr("No"));
+
+    const bool streamable = track["streamable"].toBool(true);
+    if (!streamable)
+        addRow(QObject::tr("Streamable"), QObject::tr("No"));
+
+    auto *buttons = new QDialogButtonBox(QDialogButtonBox::Close, dlg);
+    form->addRow(buttons);
+    QObject::connect(buttons, &QDialogButtonBox::rejected, dlg, &QDialog::close);
+
+    dlg->show();
+}
+
+} // namespace TrackInfoDialog
--- a/src/view/albumlistview.hpp
+++ b/src/view/albumlistview.hpp
@@ -41,6 +41,25 @@ public:
    void setAlbums(const QJsonArray &albums)
    {
        clear();
+        addAlbums(albums);
+    }
+
+    /// Configure for artist page: hide Artist column, set fixed column widths
+    /// that match the Popular Tracks list for perfect vertical alignment.
+    void setArtistPageMode()
+    {
+        setColumnHidden(2, true); // Artist — redundant on artist page
+        header()->setSectionResizeMode(0, QHeaderView::Fixed);
+        header()->setSectionResizeMode(1, QHeaderView::Stretch);
+        header()->setSectionResizeMode(3, QHeaderView::Fixed);
+        header()->setSectionResizeMode(4, QHeaderView::Fixed);
+        header()->resizeSection(0, 40);
+        header()->resizeSection(3, 120);
+        header()->resizeSection(4, 70);
+    }
+
+    void addAlbums(const QJsonArray &albums)
+    {
        QFont hiResFont;
        hiResFont.setBold(true);
        hiResFont.setPointSizeF(hiResFont.pointSizeF() * 0.85);
@@ -48,12 +67,24 @@ public:
        for (const auto &v : albums) {
            const QJsonObject a  = v.toObject();
            const QString id      = a["id"].toString();
-            const QString title  = a["title"].toString();
-            const QString artist = a["artist"].toObject()["name"].toString();
+            const QString base    = a["title"].toString();
+            const QString ver     = a["version"].toString().trimmed();
+            const QString title   = ver.isEmpty() ? base : base + QStringLiteral(" (") + ver + QLatin1Char(')');
+
+            const QJsonValue artistNameVal = a["artist"].toObject()["name"];
+            const QString artist = artistNameVal.isObject()
+                ? artistNameVal.toObject()["display"].toString()
+                : artistNameVal.toString();
+
            const QString date = a["release_date_original"].toString();
-            const QString year   = date.left(4);
+            const QString year = date.isEmpty()
+                ? a["dates"].toObject()["original"].toString().left(4)
+                : date.left(4);
+            const qint64 artistId = static_cast<qint64>(a["artist"].toObject()["id"].toDouble());
+
            const int tracks  = a["tracks_count"].toInt();
-            const bool hiRes     = a["hires_streamable"].toBool();
+            const bool hiRes  = a["hires_streamable"].toBool()
+                             || a["rights"].toObject()["hires_streamable"].toBool();

            auto *item = new QTreeWidgetItem(this);
            if (hiRes) {
@@ -67,6 +98,7 @@ public:
            item->setText(3, year);
            item->setText(4, tracks > 0 ? QString::number(tracks) : QString());
            item->setData(1, Qt::UserRole, id);
+            item->setData(2, Qt::UserRole, artistId);
        }
    }

--- a/src/view/artistview.cpp
+++ b/src/view/artistview.cpp
@@ -0,0 +1,427 @@
+#include "artistview.hpp"
+#include "albumlistview.hpp"
+#include "../model/tracklistmodel.hpp"
+
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QScrollArea>
+#include <QHeaderView>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QPixmap>
+#include <QUrl>
+#include <QFont>
+#include <QRegularExpression>
+
+// Shared button style (mirrors TrackContextHeader)
+static const QString kBtnBase = QStringLiteral(
+    "QPushButton { padding: 5px 16px; border-radius: 4px; font-weight: bold; }"
+);
+
+// Section-toggle style: flat QPushButton, truly left-aligned
+static const QString kToggleStyle = QStringLiteral(
+    "QPushButton { text-align: left; font-weight: bold; font-size: 13px;"
+    "  padding: 6px 8px; border: none; border-bottom: 1px solid #333;"
+    "  background: transparent; }"
+    "QPushButton:hover { background: #1e1e1e; }"
+);
+
+// ---------------------------------------------------------------------------
+// ArtistSection
+// ---------------------------------------------------------------------------
+
+ArtistSection::ArtistSection(const QString &title, const QString &releaseType, QWidget *parent)
+    : QWidget(parent)
+    , m_baseTitle(title)
+    , m_releaseType(releaseType)
+{
+    auto *layout = new QVBoxLayout(this);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    m_toggle = new QPushButton(this);
+    m_toggle->setCheckable(true);
+    m_toggle->setChecked(true);
+    m_toggle->setFlat(true);
+    m_toggle->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    m_toggle->setStyleSheet(kToggleStyle);
+    layout->addWidget(m_toggle);
+
+    m_list = new AlbumListView(this);
+    layout->addWidget(m_list);
+
+    connect(m_toggle, &QPushButton::toggled, this, [this](bool checked) {
+        m_list->setVisible(checked);
+        updateToggleText();
+    });
+    connect(m_list, &AlbumListView::albumSelected, this, &ArtistSection::albumSelected);
+
+    updateToggleText();
+}
+
+void ArtistSection::setAlbums(const QJsonArray &albums)
+{
+    m_list->setAlbums(albums);
+    updateToggleText();
+}
+
+bool ArtistSection::isEmpty() const
+{
+    return m_list->topLevelItemCount() == 0;
+}
+
+QStringList ArtistSection::albumIds() const
+{
+    QStringList ids;
+    for (int i = 0; i < m_list->topLevelItemCount(); ++i) {
+        const QString id = m_list->topLevelItem(i)->data(1, Qt::UserRole).toString();
+        if (!id.isEmpty())
+            ids.append(id);
+    }
+    return ids;
+}
+
+void ArtistSection::setArtistPageMode()
+{
+    m_list->setArtistPageMode();
+}
+
+void ArtistSection::updateToggleText()
+{
+    const int count = m_list->topLevelItemCount();
+    const QString arrow = m_toggle->isChecked() ? QStringLiteral("▼ ") : QStringLiteral("▶ ");
+    const QString text  = count > 0
+        ? QStringLiteral("%1%2  (%3)").arg(arrow, m_baseTitle).arg(count)
+        : arrow + m_baseTitle;
+    m_toggle->setText(text);
+}
+
+// ---------------------------------------------------------------------------
+// ArtistView
+// ---------------------------------------------------------------------------
+
+ArtistView::ArtistView(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
+    : QWidget(parent)
+    , m_backend(backend)
+    , m_queue(queue)
+{
+    auto *outerLayout = new QVBoxLayout(this);
+    outerLayout->setContentsMargins(0, 0, 0, 0);
+    outerLayout->setSpacing(0);
+
+    // --- Artist header (same structure as TrackContextHeader) ---
+    auto *header = new QWidget(this);
+    header->setFixedHeight(148);
+    auto *hlay = new QHBoxLayout(header);
+    hlay->setContentsMargins(12, 8, 12, 8);
+    hlay->setSpacing(14);
+
+    m_artLabel = new QLabel(header);
+    m_artLabel->setFixedSize(120, 120);
+    m_artLabel->setScaledContents(true);
+    m_artLabel->setAlignment(Qt::AlignCenter);
+    m_artLabel->setStyleSheet(QStringLiteral("background: #1a1a1a; border-radius: 4px;"));
+    hlay->addWidget(m_artLabel, 0, Qt::AlignVCenter);
+
+    auto *info = new QWidget(header);
+    auto *vlay = new QVBoxLayout(info);
+    vlay->setContentsMargins(0, 0, 0, 0);
+    vlay->setSpacing(4);
+
+    m_nameLabel = new QLabel(info);
+    QFont f = m_nameLabel->font();
+    f.setPointSize(f.pointSize() + 5);
+    f.setBold(true);
+    m_nameLabel->setFont(f);
+    vlay->addWidget(m_nameLabel);
+
+    m_bioEdit = new QTextEdit(info);
+    m_bioEdit->setReadOnly(true);
+    m_bioEdit->setFrameShape(QFrame::NoFrame);
+    m_bioEdit->setMaximumHeight(56);
+    m_bioEdit->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+    m_bioEdit->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    vlay->addWidget(m_bioEdit);
+
+    auto *btnRow = new QHBoxLayout;
+    btnRow->setSpacing(8);
+    btnRow->setContentsMargins(0, 4, 0, 0);
+
+    static const QString kOutlineBtn = kBtnBase +
+        QStringLiteral("QPushButton { background: #2a2a2a; color: #FFB232; border: 1px solid #FFB232; }"
+                       "QPushButton:pressed { background: #333; }");
+
+    m_playBtn = new QPushButton(tr("▶  Play"), info);
+    m_playBtn->setStyleSheet(kBtnBase +
+        QStringLiteral("QPushButton { background: #FFB232; color: #000; }"
+                       "QPushButton:pressed { background: #e09e28; }"));
+
+    m_shuffleTopBtn = new QPushButton(tr("⇄  Shuffle"), info);
+    m_shuffleTopBtn->setStyleSheet(kOutlineBtn);
+
+    m_shuffleBtn = new QPushButton(tr("⇄  Shuffle All"), info);
+    m_shuffleBtn->setStyleSheet(kOutlineBtn);
+
+    m_favBtn = new QPushButton(tr("♡  Favourite"), info);
+    m_favBtn->setStyleSheet(kBtnBase +
+        QStringLiteral("QPushButton { background: #2a2a2a; color: #ccc; border: 1px solid #555; }"
+                       "QPushButton:pressed { background: #333; }"));
+
+    btnRow->addWidget(m_playBtn);
+    btnRow->addWidget(m_shuffleTopBtn);
+    btnRow->addWidget(m_shuffleBtn);
+    btnRow->addWidget(m_favBtn);
+    btnRow->addStretch();
+    vlay->addLayout(btnRow);
+    vlay->addStretch(1);
+
+    hlay->addWidget(info, 1);
+    outerLayout->addWidget(header);
+
+    // --- Network manager for portrait ---
+    m_nam = new QNetworkAccessManager(this);
+    QObject::connect(m_nam, &QNetworkAccessManager::finished,
+                     this, [this](QNetworkReply *reply) {
+        reply->deleteLater();
+        if (reply->error() != QNetworkReply::NoError) return;
+        QPixmap pix;
+        if (pix.loadFromData(reply->readAll()))
+            m_artLabel->setPixmap(pix);
+    });
+
+    // --- Scrollable sections area ---
+    auto *scroll = new QScrollArea(this);
+    scroll->setWidgetResizable(true);
+    scroll->setFrameShape(QFrame::NoFrame);
+
+    auto *content = new QWidget(scroll);
+    auto *sectLayout = new QVBoxLayout(content);
+    sectLayout->setContentsMargins(0, 0, 0, 0);
+    sectLayout->setSpacing(0);
+
+    // Popular Tracks section — same toggle style as release sections
+    m_topTracksSection = new QWidget(content);
+    auto *ttLayout = new QVBoxLayout(m_topTracksSection);
+    ttLayout->setContentsMargins(0, 0, 0, 0);
+    ttLayout->setSpacing(0);
+
+    m_topTracksToggle = new QPushButton(m_topTracksSection);
+    m_topTracksToggle->setCheckable(true);
+    m_topTracksToggle->setChecked(true);
+    m_topTracksToggle->setFlat(true);
+    m_topTracksToggle->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    m_topTracksToggle->setStyleSheet(kToggleStyle);
+    ttLayout->addWidget(m_topTracksToggle);
+
+    m_topTracks = new List::Tracks(backend, queue, m_topTracksSection);
+    m_topTracks->setMaximumHeight(320);
+    // Artist page column layout: hide Artist & Album, match album-section widths
+    m_topTracks->setColumnHidden(TrackListModel::ColArtist, true);
+    m_topTracks->setColumnHidden(TrackListModel::ColAlbum, true);
+    m_topTracks->header()->setSectionResizeMode(TrackListModel::ColNumber,   QHeaderView::Fixed);
+    m_topTracks->header()->setSectionResizeMode(TrackListModel::ColTitle,    QHeaderView::Stretch);
+    m_topTracks->header()->setSectionResizeMode(TrackListModel::ColDuration, QHeaderView::Fixed);
+    m_topTracks->header()->resizeSection(TrackListModel::ColNumber,   40);
+    m_topTracks->header()->resizeSection(TrackListModel::ColDuration, 70);
+    ttLayout->addWidget(m_topTracks);
+
+    connect(m_topTracksToggle, &QPushButton::toggled, m_topTracks, &QWidget::setVisible);
+    connect(m_topTracks, &List::Tracks::playTrackRequested, this, &ArtistView::playTrackRequested);
+
+    sectLayout->addWidget(m_topTracksSection);
+
+    // Release sections
+    m_secAlbums       = new ArtistSection(tr("Albums"),        QStringLiteral("album"),       content);
+    m_secEps          = new ArtistSection(tr("Singles & EPs"), QStringLiteral("epSingle"),    content);
+    m_secLive         = new ArtistSection(tr("Live"),          QStringLiteral("live"),        content);
+    m_secCompilations = new ArtistSection(tr("Compilations"),  QStringLiteral("compilation"), content);
+    m_secOther        = new ArtistSection(tr("Other"),         QStringLiteral("other"),       content);
+
+    // Uniform column layout: hide Artist column, match fixed widths across all sections
+    for (ArtistSection *sec : {m_secAlbums, m_secEps, m_secLive, m_secCompilations, m_secOther})
+        sec->setArtistPageMode();
+
+    sectLayout->addWidget(m_secAlbums);
+    sectLayout->addWidget(m_secEps);
+    sectLayout->addWidget(m_secLive);
+    sectLayout->addWidget(m_secCompilations);
+    sectLayout->addWidget(m_secOther);
+    sectLayout->addStretch();
+
+    scroll->setWidget(content);
+    outerLayout->addWidget(scroll, 1);
+
+    // Play / shuffle top tracks
+    connect(m_playBtn,       &QPushButton::clicked, m_topTracks, [this] { m_topTracks->playAll(false); });
+    connect(m_shuffleTopBtn, &QPushButton::clicked, m_topTracks, [this] { m_topTracks->playAll(true); });
+
+    // Deep shuffle: fetch all album tracks, combine, shuffle, play
+    connect(m_shuffleBtn, &QPushButton::clicked, this, [this] {
+        const QStringList ids = allAlbumIds();
+        if (ids.isEmpty()) return;
+        m_shuffleBtn->setEnabled(false);
+        m_shuffleBtn->setText(tr("Loading…"));
+        m_backend->getAlbumsTracks(ids);
+    });
+
+    // Favourite button
+    connect(m_favBtn, &QPushButton::clicked, this, [this] {
+        if (m_artistId <= 0) return;
+        m_isFaved = !m_isFaved;
+        if (m_isFaved) {
+            m_backend->addFavArtist(m_artistId);
+            m_favArtistIds.insert(m_artistId);
+        } else {
+            m_backend->removeFavArtist(m_artistId);
+            m_favArtistIds.remove(m_artistId);
+        }
+        setFaved(m_isFaved);
+    });
+
+    // Album section connections
+    connect(m_secAlbums,       &ArtistSection::albumSelected, this, &ArtistView::albumSelected);
+    connect(m_secEps,          &ArtistSection::albumSelected, this, &ArtistView::albumSelected);
+    connect(m_secLive,         &ArtistSection::albumSelected, this, &ArtistView::albumSelected);
+    connect(m_secCompilations, &ArtistSection::albumSelected, this, &ArtistView::albumSelected);
+    connect(m_secOther,        &ArtistSection::albumSelected, this, &ArtistView::albumSelected);
+}
+
+void ArtistView::setArtist(const QJsonObject &artist)
+{
+    m_artistId = static_cast<qint64>(artist["id"].toDouble());
+    setFaved(m_favArtistIds.contains(m_artistId));
+
+    m_nameLabel->setText(artist["name"].toObject()["display"].toString());
+
+    // Biography: strip HTML tags
+    const QString bioHtml = artist["biography"].toObject()["content"].toString();
+    if (!bioHtml.isEmpty()) {
+        QString plain = bioHtml;
+        plain.remove(QRegularExpression(QStringLiteral("<[^>]*>")));
+        plain.replace(QStringLiteral("&amp;"),  QStringLiteral("&"));
+        plain.replace(QStringLiteral("&lt;"),   QStringLiteral("<"));
+        plain.replace(QStringLiteral("&gt;"),   QStringLiteral(">"));
+        plain.replace(QStringLiteral("&quot;"), QStringLiteral("\""));
+        plain.replace(QStringLiteral("&#39;"),  QStringLiteral("'"));
+        plain.replace(QStringLiteral("&nbsp;"), QStringLiteral(" "));
+        plain = plain.trimmed();
+        m_bioEdit->setPlainText(plain);
+        m_bioEdit->setVisible(!plain.isEmpty());
+    } else {
+        m_bioEdit->setVisible(false);
+    }
+
+    // Artist portrait: images.portrait.hash + format → CDN URL
+    const QJsonObject portrait = artist["images"].toObject()["portrait"].toObject();
+    const QString hash   = portrait["hash"].toString();
+    const QString format = portrait["format"].toString();
+    QString artUrl;
+    if (!hash.isEmpty()) {
+        artUrl = QStringLiteral("https://static.qobuz.com/images/artists/covers/large/%1.%2")
+                     .arg(hash, format.isEmpty() ? QStringLiteral("jpg") : format);
+    } else {
+        const QJsonObject img = artist["image"].toObject();
+        artUrl = img["large"].toString();
+        if (artUrl.isEmpty()) artUrl = img["small"].toString();
+    }
+    if (!artUrl.isEmpty() && artUrl != m_currentArtUrl) {
+        m_currentArtUrl = artUrl;
+        m_nam->get(QNetworkRequest(QUrl(artUrl)));
+    } else if (artUrl.isEmpty()) {
+        m_artLabel->setPixmap(QPixmap());
+        m_currentArtUrl.clear();
+    }
+
+    // Popular tracks (flat array)
+    const QJsonArray topTracks = artist["top_tracks"].toArray();
+    m_topTracks->loadTracks(topTracks);
+
+    const int ttCount = topTracks.size();
+    disconnect(m_topTracksToggle, &QPushButton::toggled, nullptr, nullptr);
+    connect(m_topTracksToggle, &QPushButton::toggled, m_topTracks, &QWidget::setVisible);
+    connect(m_topTracksToggle, &QPushButton::toggled, this, [this, ttCount](bool open) {
+        const QString a = open ? QStringLiteral("▼ ") : QStringLiteral("▶ ");
+        m_topTracksToggle->setText(ttCount > 0
+            ? QStringLiteral("%1Popular Tracks  (%2)").arg(a).arg(ttCount)
+            : a + tr("Popular Tracks"));
+    });
+    m_topTracksToggle->setChecked(true);
+    m_topTracks->setVisible(true);
+    m_topTracksToggle->setText(ttCount > 0
+        ? QStringLiteral("▼ Popular Tracks  (%1)").arg(ttCount)
+        : QStringLiteral("▼ Popular Tracks"));
+    m_topTracksSection->setVisible(!topTracks.isEmpty());
+
+    // Reset shuffle button state
+    m_shuffleBtn->setEnabled(true);
+    m_shuffleBtn->setText(tr("⇄  Shuffle All"));
+
+    // Clear release sections
+    for (ArtistSection *sec : {m_secAlbums, m_secEps, m_secLive, m_secCompilations, m_secOther}) {
+        sec->setAlbums({});
+        sec->setVisible(false);
+    }
+}
+
+void ArtistView::setReleases(const QString &releaseType, const QJsonArray &items,
+                              bool /*hasMore*/, int /*offset*/)
+{
+    ArtistSection *sec = nullptr;
+    if      (releaseType == QStringLiteral("album"))       sec = m_secAlbums;
+    else if (releaseType == QStringLiteral("epSingle"))    sec = m_secEps;
+    else if (releaseType == QStringLiteral("live"))        sec = m_secLive;
+    else if (releaseType == QStringLiteral("compilation")) sec = m_secCompilations;
+    else                                                   sec = m_secOther;
+
+    // Rust auto-paginates, so we always get the full list at once
+    sec->setAlbums(items);
+    sec->setVisible(!sec->isEmpty());
+}
+
+void ArtistView::setFavArtistIds(const QSet<qint64> &ids)
+{
+    m_favArtistIds = ids;
+    if (m_artistId > 0)
+        setFaved(ids.contains(m_artistId));
+}
+
+void ArtistView::onDeepShuffleTracks(const QJsonArray &tracks)
+{
+    m_shuffleBtn->setEnabled(true);
+    m_shuffleBtn->setText(tr("⇄  Shuffle All"));
+
+    if (tracks.isEmpty()) return;
+
+    m_queue->setContext(tracks, 0);
+    m_queue->shuffleNow();
+
+    const QJsonObject first = m_queue->current();
+    const qint64 id = static_cast<qint64>(first["id"].toDouble());
+    if (id > 0)
+        emit playTrackRequested(id);
+}
+
+QStringList ArtistView::allAlbumIds() const
+{
+    QStringList ids;
+    for (const ArtistSection *sec : {m_secAlbums, m_secEps, m_secLive, m_secCompilations, m_secOther})
+        ids.append(sec->albumIds());
+    return ids;
+}
+
+void ArtistView::setFaved(bool faved)
+{
+    m_isFaved = faved;
+    if (faved) {
+        m_favBtn->setText(tr("♥  Favourited"));
+        m_favBtn->setStyleSheet(kBtnBase +
+            QStringLiteral("QPushButton { background: #2a2a2a; color: #FFB232; border: 1px solid #FFB232; }"
+                           "QPushButton:pressed { background: #333; }"));
+    } else {
+        m_favBtn->setText(tr("♡  Favourite"));
+        m_favBtn->setStyleSheet(kBtnBase +
+            QStringLiteral("QPushButton { background: #2a2a2a; color: #ccc; border: 1px solid #555; }"
+                           "QPushButton:pressed { background: #333; }"));
+    }
+}
--- a/src/view/artistview.hpp
+++ b/src/view/artistview.hpp
@@ -1,64 +1,93 @@
 #pragma once

 #include "albumlistview.hpp"
+#include "../list/tracks.hpp"
+#include "../backend/qobuzbackend.hpp"
+#include "../playqueue.hpp"

 #include <QWidget>
-#include <QVBoxLayout>
 #include <QLabel>
-#include <QFont>
+#include <QTextEdit>
+#include <QPushButton>
+#include <QNetworkAccessManager>
 #include <QJsonObject>
 #include <QJsonArray>
+#include <QSet>

-/// Artist detail page: name, biography summary, and their album list.
-class ArtistView : public QWidget
+class AlbumListView;
+
+/// One collapsible section (Albums / EPs / Live / etc.) inside ArtistView.
+class ArtistSection : public QWidget
 {
    Q_OBJECT
-
 public:
-    explicit ArtistView(QWidget *parent = nullptr) : QWidget(parent)
-    {
-        auto *layout = new QVBoxLayout(this);
-        layout->setContentsMargins(8, 8, 8, 8);
-        layout->setSpacing(6);
+    explicit ArtistSection(const QString &title, const QString &releaseType, QWidget *parent = nullptr);

-        m_nameLabel = new QLabel(this);
-        QFont f = m_nameLabel->font();
-        f.setPointSize(f.pointSize() + 4);
-        f.setBold(true);
-        m_nameLabel->setFont(f);
-
-        m_bioLabel = new QLabel(this);
-        m_bioLabel->setWordWrap(true);
-        m_bioLabel->setAlignment(Qt::AlignTop | Qt::AlignLeft);
-        m_bioLabel->setMaximumHeight(80);
-
-        m_albums = new AlbumListView(this);
-
-        layout->addWidget(m_nameLabel);
-        layout->addWidget(m_bioLabel);
-        layout->addWidget(m_albums, 1);
-
-        connect(m_albums, &AlbumListView::albumSelected,
-                this, &ArtistView::albumSelected);
-    }
-
-    void setArtist(const QJsonObject &artist)
-    {
-        m_nameLabel->setText(artist["name"].toString());
-
-        const QString summary = artist["biography"].toObject()["summary"].toString();
-        m_bioLabel->setText(summary);
-        m_bioLabel->setVisible(!summary.isEmpty());
-
-        const QJsonArray albums = artist["albums"].toObject()["items"].toArray();
-        m_albums->setAlbums(albums);
-    }
+    void setAlbums(const QJsonArray &albums);
+    bool isEmpty() const;
+    QStringList albumIds() const;
+    void setArtistPageMode();

 signals:
    void albumSelected(const QString &albumId);

 private:
-    QLabel        *m_nameLabel = nullptr;
-    QLabel        *m_bioLabel  = nullptr;
-    AlbumListView *m_albums    = nullptr;
+    QString        m_baseTitle;
+    QString        m_releaseType;
+    QPushButton   *m_toggle       = nullptr;
+    AlbumListView *m_list         = nullptr;
+
+    void updateToggleText();
+};
+
+/// Artist detail page.
+class ArtistView : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit ArtistView(QobuzBackend *backend, PlayQueue *queue, QWidget *parent = nullptr);
+
+    void setArtist(const QJsonObject &artist);
+    void setReleases(const QString &releaseType, const QJsonArray &items,
+                     bool hasMore = false, int offset = 0);
+    void setFavArtistIds(const QSet<qint64> &ids);
+    void onDeepShuffleTracks(const QJsonArray &tracks);
+
+signals:
+    void albumSelected(const QString &albumId);
+    void playTrackRequested(qint64 trackId);
+
+private:
+    QobuzBackend *m_backend    = nullptr;
+    PlayQueue    *m_queue      = nullptr;
+    qint64        m_artistId   = 0;
+
+    // Header widgets
+    QLabel                *m_artLabel   = nullptr;
+    QLabel                *m_nameLabel  = nullptr;
+    QTextEdit             *m_bioEdit    = nullptr;
+    QPushButton           *m_playBtn       = nullptr;
+    QPushButton           *m_shuffleTopBtn = nullptr;
+    QPushButton           *m_shuffleBtn    = nullptr;
+    QPushButton           *m_favBtn        = nullptr;
+    QNetworkAccessManager *m_nam        = nullptr;
+    QString                m_currentArtUrl;
+    bool                   m_isFaved    = false;
+    QSet<qint64>           m_favArtistIds;
+
+    // Popular tracks section
+    QWidget      *m_topTracksSection = nullptr;
+    QPushButton  *m_topTracksToggle  = nullptr;
+    List::Tracks *m_topTracks        = nullptr;
+
+    // Release sections
+    ArtistSection *m_secAlbums       = nullptr;
+    ArtistSection *m_secEps          = nullptr;
+    ArtistSection *m_secLive         = nullptr;
+    ArtistSection *m_secCompilations = nullptr;
+    ArtistSection *m_secOther        = nullptr;
+
+    QStringList allAlbumIds() const;
+    void setFaved(bool faved);
 };
--- a/src/view/context/view.cpp
+++ b/src/view/context/view.cpp
@@ -22,11 +22,7 @@ View::View(QobuzBackend *backend, QWidget *parent)
    layout->setContentsMargins(8, 8, 8, 8);
    layout->setSpacing(6);

-    m_albumArt = new QLabel(container);
-    m_albumArt->setAlignment(Qt::AlignCenter);
-    m_albumArt->setStyleSheet(QStringLiteral(
-        "background: #1a1a1a; border-radius: 4px;"));
-    m_albumArt->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    m_albumArt = new ArtWidget(container);
    layout->addWidget(m_albumArt);

    m_title = new QLabel(tr("Not playing"), container);
@@ -45,7 +41,6 @@ View::View(QobuzBackend *backend, QWidget *parent)

    layout->addStretch();
    setWidget(container);
-    setMinimumWidth(160);

    connect(m_backend, &QobuzBackend::trackChanged, this, &View::onTrackChanged);
 }
@@ -60,7 +55,6 @@ void View::onTrackChanged(const QJsonObject &track)
    m_title->setText(title.isEmpty() ? tr("Not playing") : title);
    m_artist->setText(artist);

-    // Prefer "large" image, fall back to "small"
    const QJsonObject img = track["album"].toObject()["image"].toObject();
    QString artUrl = img["large"].toString();
    if (artUrl.isEmpty())
@@ -77,26 +71,9 @@ void View::onArtReady(QNetworkReply *reply)
    reply->deleteLater();
    if (reply->error() != QNetworkReply::NoError)
        return;
-    if (m_artPixmap.loadFromData(reply->readAll()))
-        scaleArtToWidth();
-}
-
-void View::resizeEvent(QResizeEvent *event)
-{
-    QDockWidget::resizeEvent(event);
-    if (m_artPixmap.isNull()) return;
-    // Use the new dock width from the event so we don't lag behind the layout
-    const int side = qMax(32, event->size().width() - 16);
-    m_albumArt->setFixedHeight(side);
-    m_albumArt->setPixmap(m_artPixmap.scaled(side, side, Qt::KeepAspectRatio, Qt::SmoothTransformation));
-}
-
-void View::scaleArtToWidth()
-{
-    if (m_artPixmap.isNull()) return;
-    const int side = qMax(32, width() - 16);
-    m_albumArt->setFixedHeight(side);
-    m_albumArt->setPixmap(m_artPixmap.scaled(side, side, Qt::KeepAspectRatio, Qt::SmoothTransformation));
+    QPixmap pix;
+    if (pix.loadFromData(reply->readAll()))
+        m_albumArt->setPixmap(pix);
 }

 } // namespace Context
--- a/src/view/context/view.hpp
+++ b/src/view/context/view.hpp
@@ -3,15 +3,49 @@
 #include "../../backend/qobuzbackend.hpp"

 #include <QDockWidget>
+#include <QWidget>
 #include <QLabel>
 #include <QPixmap>
-#include <QResizeEvent>
+#include <QPainter>
+#include <QPaintEvent>
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 #include <QJsonObject>

 namespace Context
 {
+    /// Square art widget: always as wide as its parent allows, height follows width.
+    class ArtWidget : public QWidget
+    {
+    public:
+        explicit ArtWidget(QWidget *parent = nullptr) : QWidget(parent)
+        {
+            setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+        }
+
+        void setPixmap(const QPixmap &px) { m_pix = px; update(); }
+        bool hasHeightForWidth() const override { return true; }
+        int  heightForWidth(int w) const override { return w; }
+
+    protected:
+        void paintEvent(QPaintEvent *) override
+        {
+            QPainter p(this);
+            if (m_pix.isNull()) {
+                p.fillRect(rect(), QColor(0x1a, 0x1a, 0x1a));
+                return;
+            }
+            const QPixmap scaled = m_pix.scaled(size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
+            p.fillRect(rect(), QColor(0x1a, 0x1a, 0x1a));
+            p.drawPixmap((width()  - scaled.width())  / 2,
+                         (height() - scaled.height()) / 2,
+                         scaled);
+        }
+
+    private:
+        QPixmap m_pix;
+    };
+
    class View : public QDockWidget
    {
        Q_OBJECT
@@ -23,18 +57,12 @@ namespace Context
        void onTrackChanged(const QJsonObject &track);
        void onArtReady(QNetworkReply *reply);

-    protected:
-        void resizeEvent(QResizeEvent *event) override;
-
    private:
-        void scaleArtToWidth();
-
        QobuzBackend          *m_backend       = nullptr;
-        QLabel                *m_albumArt      = nullptr;
+        ArtWidget             *m_albumArt      = nullptr;
        QLabel                *m_title         = nullptr;
        QLabel                *m_artist        = nullptr;
        QNetworkAccessManager *m_nam           = nullptr;
        QString                m_currentArtUrl;
-        QPixmap                m_artPixmap;
    };
 } // namespace Context
--- a/src/view/genrebrowser.cpp
+++ b/src/view/genrebrowser.cpp
@@ -0,0 +1,794 @@
+#include "genrebrowser.hpp"
+
+#include <QAction>
+#include <QDialog>
+#include <QDialogButtonBox>
+#include <QHeaderView>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QListWidget>
+#include <QMenu>
+#include <QPushButton>
+#include <QScrollBar>
+#include <QSignalBlocker>
+#include <QTimer>
+#include <QTreeWidgetItem>
+#include <QVBoxLayout>
+
+#include <algorithm>
+
+GenreBrowserView::GenreBrowserView(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
+    : QWidget(parent)
+    , m_backend(backend)
+    , m_queue(queue)
+{
+    auto *layout = new QVBoxLayout(this);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+
+    auto *topBar = new QWidget(this);
+    auto *topLayout = new QHBoxLayout(topBar);
+    topLayout->setContentsMargins(8, 6, 8, 6);
+    topLayout->setSpacing(6);
+
+    QFont topFont = topBar->font();
+    if (topFont.pointSize() > 0)
+        topFont.setPointSize(topFont.pointSize() + 1);
+    static constexpr int controlHeight = 30;
+
+    m_browseLabel = new QLabel(tr("Show:"), this);
+    m_browseLabel->setFont(topFont);
+    topLayout->addWidget(m_browseLabel);
+    m_kindCombo = new QComboBox(this);
+    m_kindCombo->addItem(tr("Albums"), QStringLiteral("albums"));
+    m_kindCombo->addItem(tr("Playlists"), QStringLiteral("playlists"));
+    m_kindCombo->setFont(topFont);
+    m_kindCombo->setMinimumWidth(110);
+    m_kindCombo->setFixedHeight(controlHeight);
+    topLayout->addWidget(m_kindCombo);
+
+    m_gapAfterKind = new QWidget(this);
+    m_gapAfterKind->setFixedWidth(6);
+    topLayout->addWidget(m_gapAfterKind);
+
+    m_genreLabel = new QLabel(tr("Genre:"), this);
+    m_genreLabel->setFont(topFont);
+    topLayout->addWidget(m_genreLabel);
+    m_genreCombo = new QComboBox(this);
+    m_genreCombo->setFont(topFont);
+    m_genreCombo->setMinimumWidth(180);
+    m_genreCombo->setFixedHeight(controlHeight);
+    topLayout->addWidget(m_genreCombo);
+
+    m_gapAfterGenre = new QWidget(this);
+    m_gapAfterGenre->setFixedWidth(10);
+    topLayout->addWidget(m_gapAfterGenre);
+
+    m_typeLabel = new QLabel(tr("Type:"), this);
+    m_typeLabel->setFont(topFont);
+    topLayout->addWidget(m_typeLabel);
+    m_typeCombo = new QComboBox(this);
+    m_typeCombo->setFont(topFont);
+    m_typeCombo->setMinimumWidth(180);
+    m_typeCombo->setFixedHeight(controlHeight);
+    topLayout->addWidget(m_typeCombo);
+
+    m_playlistSearchLabel = new QLabel(tr("Search:"), this);
+    m_playlistSearchLabel->setFont(topFont);
+    m_playlistSearchLabel->setVisible(false);
+    topLayout->addWidget(m_playlistSearchLabel);
+
+    m_playlistSearchBox = new QLineEdit(this);
+    m_playlistSearchBox->setFont(topFont);
+    m_playlistSearchBox->setPlaceholderText(tr("Search playlists..."));
+    m_playlistSearchBox->setClearButtonEnabled(true);
+    m_playlistSearchBox->setVisible(false);
+    m_playlistSearchBox->setMinimumWidth(220);
+    m_playlistSearchBox->setMaximumWidth(320);
+    m_playlistSearchBox->setFixedHeight(controlHeight);
+    topLayout->addWidget(m_playlistSearchBox);
+
+    m_playlistSearchBtn = new QPushButton(tr("Go"), this);
+    m_playlistSearchBtn->setFont(topFont);
+    m_playlistSearchBtn->setVisible(false);
+    m_playlistSearchBtn->setFixedHeight(controlHeight);
+    topLayout->addWidget(m_playlistSearchBtn);
+
+    m_deepShuffleBtn = new QPushButton(tr("⇄  Deep Shuffle"), this);
+    m_deepShuffleBtn->setFont(topFont);
+    m_deepShuffleBtn->setVisible(false);
+    m_deepShuffleBtn->setFixedHeight(controlHeight);
+    topLayout->addWidget(m_deepShuffleBtn);
+
+    topLayout->addStretch();
+    layout->addWidget(topBar);
+
+    m_resultsStack = new QStackedWidget(this);
+
+    m_albumList = new AlbumListView(this);
+    m_albumList->setContextMenuPolicy(Qt::CustomContextMenu);
+
+    m_playlistList = new QTreeWidget(this);
+    m_playlistList->setColumnCount(4);
+    m_playlistList->setHeaderLabels({tr(""), tr("Playlist"), tr("Owner"), tr("Tracks")});
+    m_playlistList->setRootIsDecorated(false);
+    m_playlistList->setAlternatingRowColors(true);
+    m_playlistList->setSelectionBehavior(QAbstractItemView::SelectRows);
+    m_playlistList->setSortingEnabled(true);
+    m_playlistList->setContextMenuPolicy(Qt::CustomContextMenu);
+    m_playlistList->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
+    m_playlistList->header()->setSectionResizeMode(1, QHeaderView::Stretch);
+    m_playlistList->header()->setSectionResizeMode(2, QHeaderView::Stretch);
+    m_playlistList->header()->setSectionResizeMode(3, QHeaderView::ResizeToContents);
+    m_playlistList->header()->setStretchLastSection(false);
+
+    auto *playlistPage = new QWidget(this);
+    auto *playlistPageLayout = new QVBoxLayout(playlistPage);
+    playlistPageLayout->setContentsMargins(0, 0, 0, 0);
+    playlistPageLayout->setSpacing(0);
+    playlistPageLayout->addWidget(m_playlistList, 1);
+
+    m_loadMorePlaylistsBtn = new QPushButton(tr("Load more playlists…"), this);
+    m_loadMorePlaylistsBtn->hide();
+    playlistPageLayout->addWidget(m_loadMorePlaylistsBtn);
+
+    m_resultsStack->addWidget(m_albumList);
+    m_resultsStack->addWidget(playlistPage);
+    layout->addWidget(m_resultsStack, 1);
+
+    connect(m_backend, &QobuzBackend::genresLoaded,
+            this, &GenreBrowserView::onGenresLoaded);
+    connect(m_backend, &QobuzBackend::featuredAlbumsLoaded,
+            this, &GenreBrowserView::onFeaturedAlbumsLoaded);
+    connect(m_backend, &QobuzBackend::featuredPlaylistsLoaded,
+            this, &GenreBrowserView::onFeaturedPlaylistsLoaded);
+    connect(m_backend, &QobuzBackend::discoverPlaylistsLoaded,
+            this, &GenreBrowserView::onDiscoverPlaylistsLoaded);
+    connect(m_backend, &QobuzBackend::playlistSearchLoaded,
+            this, &GenreBrowserView::onPlaylistSearchLoaded);
+
+    connect(m_genreCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
+            this, [this](int index) {
+        const QString data = m_genreCombo->itemData(index).toString();
+        if (data == QStringLiteral("__multi__")) {
+            if (!chooseMultiGenres()) {
+                const QSignalBlocker blocker(m_genreCombo);
+                m_genreCombo->setCurrentIndex(m_lastGenreComboIndex);
+                return;
+            }
+            m_lastGenreComboIndex = index;
+            updateMultiGenreLabel();
+        } else {
+            m_lastGenreComboIndex = index;
+            if (data == QStringLiteral("__all__")) {
+                m_multiGenreIds.clear();
+                updateMultiGenreLabel();
+            }
+        }
+        onSelectionChanged();
+    });
+    connect(m_kindCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
+            this, [this](int) {
+        refreshGenreTypeChoices();
+        onSelectionChanged();
+    });
+    connect(m_typeCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
+            this, &GenreBrowserView::onSelectionChanged);
+    connect(m_playlistSearchBox, &QLineEdit::returnPressed,
+            this, &GenreBrowserView::onSelectionChanged);
+    connect(m_playlistSearchBtn, &QPushButton::clicked,
+            this, &GenreBrowserView::onSelectionChanged);
+    connect(m_deepShuffleBtn, &QPushButton::clicked,
+            this, &GenreBrowserView::onDeepShuffleClicked);
+    connect(m_albumList, &AlbumListView::albumSelected,
+            this, &GenreBrowserView::albumSelected);
+    connect(m_albumList, &QTreeWidget::customContextMenuRequested,
+            this, &GenreBrowserView::onAlbumContextMenu);
+    connect(m_playlistList, &QTreeWidget::itemDoubleClicked,
+            this, &GenreBrowserView::onPlaylistActivated);
+    connect(m_playlistList, &QTreeWidget::customContextMenuRequested,
+            this, &GenreBrowserView::onPlaylistContextMenu);
+    connect(m_albumList->verticalScrollBar(), &QScrollBar::valueChanged,
+            this, &GenreBrowserView::onAlbumScroll);
+    connect(m_playlistList->verticalScrollBar(), &QScrollBar::valueChanged,
+            this, &GenreBrowserView::onPlaylistScroll);
+    connect(m_loadMorePlaylistsBtn, &QPushButton::clicked, this, [this] {
+        m_loadMorePlaylistsBtn->hide();
+        requestPlaylistsPage(m_lastPlaylistGenreIds, m_lastPlaylistType,
+                             m_lastPlaylistTags, m_lastPlaylistQuery,
+                             m_playlistOffset, true);
+    });
+
+    m_kindCombo->setCurrentIndex(0);
+    refreshModeUi();
+}
+
+void GenreBrowserView::ensureGenresLoaded()
+{
+    if (!m_genresLoaded)
+        m_backend->getGenres();
+}
+
+void GenreBrowserView::setBrowseMode(BrowseMode mode)
+{
+    if (m_mode == mode)
+        return;
+
+    m_mode = mode;
+    refreshModeUi();
+    onSelectionChanged();
+}
+
+void GenreBrowserView::refreshModeUi()
+{
+    const bool genreMode = (m_mode == BrowseMode::Genres);
+
+    m_browseLabel->setVisible(genreMode);
+    m_kindCombo->setVisible(genreMode);
+    m_gapAfterKind->setVisible(genreMode);
+    m_genreLabel->setVisible(genreMode);
+    m_genreCombo->setVisible(genreMode);
+    m_gapAfterGenre->setVisible(genreMode);
+    m_typeLabel->setVisible(genreMode);
+    m_typeCombo->setVisible(genreMode);
+
+    if (genreMode) {
+        m_playlistSearchBox->setVisible(false);
+        m_playlistSearchLabel->setVisible(false);
+        m_playlistSearchBtn->setVisible(false);
+        m_deepShuffleBtn->setVisible(m_kindCombo->currentData().toString() == QStringLiteral("albums"));
+        refreshGenreTypeChoices();
+        return;
+    }
+
+    m_typeCombo->blockSignals(true);
+    m_typeCombo->clear();
+    m_typeCombo->addItem(tr("Search"), QStringLiteral("search"));
+    m_typeCombo->blockSignals(false);
+    m_playlistSearchLabel->setVisible(true);
+    m_playlistSearchBox->setVisible(true);
+    m_playlistSearchBtn->setVisible(true);
+    m_deepShuffleBtn->setVisible(false);
+    m_resultsStack->setCurrentIndex(1);
+}
+
+void GenreBrowserView::refreshGenreTypeChoices()
+{
+    m_typeCombo->blockSignals(true);
+    m_typeCombo->clear();
+
+    const QString kind = m_kindCombo->currentData().toString();
+    if (kind == QStringLiteral("playlists")) {
+        m_typeCombo->addItem(tr("Featured: Last Created"), QStringLiteral("last-created"));
+        m_typeCombo->addItem(tr("Discover: New"), QStringLiteral("discover-new"));
+        m_typeCombo->addItem(tr("Discover: Hi-Res"), QStringLiteral("discover-hires"));
+        m_typeCombo->addItem(tr("Discover: Focus"), QStringLiteral("discover-focus"));
+        m_typeCombo->addItem(tr("Discover: Qobuz Digs"), QStringLiteral("discover-qobuzdigs"));
+        m_resultsStack->setCurrentIndex(1);
+        m_deepShuffleBtn->setVisible(false);
+    } else {
+        m_typeCombo->addItem(tr("New Releases"), QStringLiteral("new-releases"));
+        m_typeCombo->addItem(tr("Best Sellers"), QStringLiteral("best-sellers"));
+        m_typeCombo->addItem(tr("Most Streamed"), QStringLiteral("most-streamed"));
+        m_typeCombo->addItem(tr("Editor Picks"), QStringLiteral("editor-picks"));
+        m_typeCombo->addItem(tr("Press Awards"), QStringLiteral("press-awards"));
+        m_resultsStack->setCurrentIndex(0);
+        m_deepShuffleBtn->setVisible(m_mode == BrowseMode::Genres);
+    }
+
+    m_typeCombo->blockSignals(false);
+}
+
+QString GenreBrowserView::currentGenreIds() const
+{
+    const QString data = m_genreCombo->currentData().toString();
+    if (data == QStringLiteral("__all__"))
+        return QString();
+
+    if (data == QStringLiteral("__multi__")) {
+        if (m_multiGenreIds.isEmpty())
+            return QString();
+
+        QList<qint64> ids = m_multiGenreIds.values();
+        std::sort(ids.begin(), ids.end());
+        QStringList out;
+        out.reserve(ids.size());
+        for (qint64 id : ids)
+            out.push_back(QString::number(id));
+        return out.join(QLatin1Char(','));
+    }
+
+    return data;
+}
+
+bool GenreBrowserView::chooseMultiGenres()
+{
+    QDialog dlg(this);
+    dlg.setWindowTitle(tr("Select genres"));
+    dlg.resize(320, 420);
+
+    auto *layout = new QVBoxLayout(&dlg);
+    auto *list = new QListWidget(&dlg);
+    list->setAlternatingRowColors(true);
+    layout->addWidget(list, 1);
+
+    for (int i = 0; i < m_genreCombo->count(); ++i) {
+        const QString data = m_genreCombo->itemData(i).toString();
+        if (data == QStringLiteral("__all__") || data == QStringLiteral("__multi__"))
+            continue;
+
+        auto *item = new QListWidgetItem(m_genreCombo->itemText(i), list);
+        item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
+        const qint64 id = data.toLongLong();
+        item->setData(Qt::UserRole, id);
+        item->setCheckState(m_multiGenreIds.contains(id) ? Qt::Checked : Qt::Unchecked);
+    }
+
+    auto *buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &dlg);
+    layout->addWidget(buttons);
+    connect(buttons, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);
+    connect(buttons, &QDialogButtonBox::rejected, &dlg, &QDialog::reject);
+
+    if (dlg.exec() != QDialog::Accepted)
+        return false;
+
+    m_multiGenreIds.clear();
+    for (int i = 0; i < list->count(); ++i) {
+        QListWidgetItem *item = list->item(i);
+        if (item->checkState() == Qt::Checked)
+            m_multiGenreIds.insert(item->data(Qt::UserRole).toLongLong());
+    }
+    return true;
+}
+
+void GenreBrowserView::updateMultiGenreLabel()
+{
+    const int multiIndex = m_genreCombo->count() - 1;
+    if (multiIndex < 0)
+        return;
+
+    const QString text = m_multiGenreIds.isEmpty()
+        ? tr("Multiple...")
+        : tr("Multiple (%1)").arg(m_multiGenreIds.size());
+    m_genreCombo->setItemText(multiIndex, text);
+}
+
+void GenreBrowserView::onGenresLoaded(const QJsonObject &result)
+{
+    m_genresLoaded = true;
+    m_genreCombo->blockSignals(true);
+    m_genreCombo->clear();
+    m_genreCombo->addItem(tr("All genres"), QStringLiteral("__all__"));
+
+    const QJsonArray items = result["items"].toArray();
+    for (const auto &value : items) {
+        const QJsonObject genre = value.toObject();
+        m_genreCombo->addItem(
+            genre["name"].toString(),
+            static_cast<qint64>(genre["id"].toDouble()));
+    }
+
+    m_genreCombo->addItem(tr("Multiple..."), QStringLiteral("__multi__"));
+    updateMultiGenreLabel();
+    m_lastGenreComboIndex = 0;
+    m_genreCombo->setCurrentIndex(0);
+
+    m_genreCombo->blockSignals(false);
+    onSelectionChanged();
+}
+
+void GenreBrowserView::onFeaturedAlbumsLoaded(const QJsonObject &result)
+{
+    m_resultsStack->setCurrentIndex(0);
+    const QString genreIds = result["genre_ids"].toString();
+    const QString type = result["type"].toString();
+    const int offset = result["offset"].toInt();
+    if (genreIds != m_lastAlbumGenreIds || type != m_lastAlbumType)
+        return;
+
+    const QJsonArray items = result["items"].toArray();
+    if (offset <= 0)
+        m_albumList->setAlbums(items);
+    else
+        m_albumList->addAlbums(items);
+
+    m_albumTotal = result["total"].toInt();
+    m_albumOffset = offset + items.size();
+    if (items.isEmpty())
+        m_albumTotal = m_albumOffset;
+    m_loadingAlbums = false;
+
+    if (m_collectAlbumsForDeepShuffle) {
+        if (m_albumOffset < m_albumTotal) {
+            requestAlbumsPage(m_lastAlbumGenreIds, m_lastAlbumType, m_albumOffset, true);
+            return;
+        }
+        m_collectAlbumsForDeepShuffle = false;
+        startDeepShuffleFromLoadedAlbums();
+        return;
+    }
+
+    // If the viewport is not scrollable yet, eagerly fetch more pages.
+    // Deferred: the scrollbar maximum isn't updated until after layout runs.
+    QTimer::singleShot(0, this, [this] {
+        QScrollBar *bar = m_albumList->verticalScrollBar();
+        if (bar && bar->maximum() == 0 && m_albumOffset < m_albumTotal)
+            requestAlbumsPage(m_lastAlbumGenreIds, m_lastAlbumType, m_albumOffset, true);
+    });
+}
+
+void GenreBrowserView::onFeaturedPlaylistsLoaded(const QJsonObject &result)
+{
+    m_resultsStack->setCurrentIndex(1);
+    const QString genreIds = result["genre_ids"].toString();
+    const QString type = result["type"].toString();
+    const int offset = result["offset"].toInt();
+    if (genreIds != m_lastPlaylistGenreIds || type != m_lastPlaylistType)
+        return;
+
+    const QJsonArray items = result["items"].toArray();
+    setPlaylistItems(items, offset > 0);
+    m_playlistTotal = result["total"].toInt();
+    m_playlistOffset = offset + items.size();
+    if (items.isEmpty())
+        m_playlistTotal = m_playlistOffset;
+    m_loadingPlaylists = false;
+
+    QTimer::singleShot(0, this, [this] {
+        QScrollBar *bar = m_playlistList->verticalScrollBar();
+        if (bar && bar->maximum() == 0 && m_playlistOffset < m_playlistTotal)
+            requestPlaylistsPage(m_lastPlaylistGenreIds, m_lastPlaylistType, m_lastPlaylistTags, m_lastPlaylistQuery, m_playlistOffset, true);
+    });
+}
+
+void GenreBrowserView::onDiscoverPlaylistsLoaded(const QJsonObject &result)
+{
+    m_resultsStack->setCurrentIndex(1);
+    const QString genreIds = result["genre_ids"].toString();
+    const QString tags = result["tags"].toString();
+    const int offset = result["offset"].toInt();
+    if (genreIds != m_lastPlaylistGenreIds || tags != m_lastPlaylistTags)
+        return;
+
+    const QJsonArray items = result["items"].toArray();
+    setPlaylistItems(items, offset > 0);
+    m_playlistTotal = result["total"].toInt();
+    m_playlistOffset = offset + items.size();
+    if (items.isEmpty())
+        m_playlistTotal = m_playlistOffset;
+    m_loadingPlaylists = false;
+
+    QTimer::singleShot(0, this, [this] {
+        QScrollBar *bar = m_playlistList->verticalScrollBar();
+        if (bar && bar->maximum() == 0 && m_playlistOffset < m_playlistTotal)
+            requestPlaylistsPage(m_lastPlaylistGenreIds, m_lastPlaylistType, m_lastPlaylistTags, m_lastPlaylistQuery, m_playlistOffset, true);
+    });
+}
+
+void GenreBrowserView::onPlaylistSearchLoaded(const QJsonObject &result)
+{
+    m_resultsStack->setCurrentIndex(1);
+    const QString query = result["query"].toString();
+    const int offset = result["offset"].toInt();
+    if (query != m_lastPlaylistQuery)
+        return;
+
+    const QJsonArray items = result["items"].toArray();
+    setPlaylistItems(items, offset > 0);
+    m_playlistTotal = result["total"].toInt();
+    m_playlistOffset = offset + items.size();
+    if (items.isEmpty())
+        m_playlistTotal = m_playlistOffset;
+    m_loadingPlaylists = false;
+
+    // Eagerly fill the viewport, then switch to a manual "Load more" button.
+    if (m_playlistOffset >= m_playlistTotal) {
+        m_loadMorePlaylistsBtn->hide();
+        m_searchViewportFilled = true;
+    } else if (!m_searchViewportFilled) {
+        QTimer::singleShot(0, this, [this] {
+            QScrollBar *bar = m_playlistList->verticalScrollBar();
+            if (bar && bar->maximum() == 0 && m_playlistOffset < m_playlistTotal) {
+                requestPlaylistsPage(m_lastPlaylistGenreIds, m_lastPlaylistType,
+                                     m_lastPlaylistTags, m_lastPlaylistQuery,
+                                     m_playlistOffset, true);
+            } else {
+                m_searchViewportFilled = true;
+                m_loadMorePlaylistsBtn->setVisible(m_playlistOffset < m_playlistTotal);
+            }
+        });
+    } else {
+        m_loadMorePlaylistsBtn->setVisible(true);
+    }
+}
+
+void GenreBrowserView::onSelectionChanged()
+{
+    m_collectAlbumsForDeepShuffle = false;
+
+    if (m_mode == BrowseMode::PlaylistSearch) {
+        m_resultsStack->setCurrentIndex(1);
+        m_playlistSearchLabel->setVisible(true);
+        m_playlistSearchBox->setVisible(true);
+        m_playlistSearchBtn->setVisible(true);
+        m_deepShuffleBtn->setVisible(false);
+        m_deepShuffleBtn->setEnabled(true);
+        m_deepShuffleBtn->setText(tr("⇄  Deep Shuffle"));
+        const QString query = m_playlistSearchBox->text().trimmed();
+        if (query.size() < 2) {
+            m_playlistList->clear();
+            m_playlistOffset = 0;
+            m_playlistTotal = 0;
+            m_loadingPlaylists = false;
+        } else {
+            requestPlaylistsPage(QString(), QStringLiteral("search"), QString(), query, 0, false);
+        }
+        return;
+    }
+
+    if (m_genreCombo->count() == 0)
+        return;
+
+    const QString genreIds = currentGenreIds();
+    const QString type = m_typeCombo->currentData().toString();
+    const QString kind = m_kindCombo->currentData().toString();
+    m_playlistSearchLabel->setVisible(false);
+    m_playlistSearchBox->setVisible(false);
+    m_playlistSearchBtn->setVisible(false);
+
+    if (kind == QStringLiteral("playlists")) {
+        m_resultsStack->setCurrentIndex(1);
+        m_deepShuffleBtn->setVisible(false);
+        m_deepShuffleBtn->setEnabled(true);
+        m_deepShuffleBtn->setText(tr("⇄  Deep Shuffle"));
+        if (type == QStringLiteral("discover-new"))
+            requestPlaylistsPage(genreIds, type, QStringLiteral("new"), QString(), 0, false);
+        else if (type == QStringLiteral("discover-hires"))
+            requestPlaylistsPage(genreIds, type, QStringLiteral("hi-res"), QString(), 0, false);
+        else if (type == QStringLiteral("discover-focus"))
+            requestPlaylistsPage(genreIds, type, QStringLiteral("focus"), QString(), 0, false);
+        else if (type == QStringLiteral("discover-qobuzdigs"))
+            requestPlaylistsPage(genreIds, type, QStringLiteral("qobuzdigs"), QString(), 0, false);
+        else
+            requestPlaylistsPage(genreIds, type, QString(), QString(), 0, false);
+    } else {
+        m_resultsStack->setCurrentIndex(0);
+        m_deepShuffleBtn->setVisible(m_mode == BrowseMode::Genres);
+        m_deepShuffleBtn->setEnabled(true);
+        m_deepShuffleBtn->setText(tr("⇄  Deep Shuffle"));
+        requestAlbumsPage(genreIds, type, 0, false);
+    }
+}
+
+QStringList GenreBrowserView::currentAlbumIds() const
+{
+    QStringList ids;
+    for (int i = 0; i < m_albumList->topLevelItemCount(); ++i) {
+        const QString id = m_albumList->topLevelItem(i)->data(1, Qt::UserRole).toString();
+        if (!id.isEmpty())
+            ids.push_back(id);
+    }
+    return ids;
+}
+
+void GenreBrowserView::startDeepShuffleFromLoadedAlbums()
+{
+    const QStringList albumIds = currentAlbumIds();
+    if (albumIds.isEmpty()) {
+        m_deepShuffleBtn->setEnabled(true);
+        m_deepShuffleBtn->setText(tr("⇄  Deep Shuffle"));
+        return;
+    }
+
+    m_waitingDeepShuffle = true;
+    m_deepShuffleBtn->setEnabled(false);
+    m_deepShuffleBtn->setText(tr("Loading…"));
+    m_backend->getAlbumsTracks(albumIds);
+}
+
+void GenreBrowserView::requestAlbumsPage(const QString &genreIds, const QString &type, int offset, bool append)
+{
+    if (append && m_loadingAlbums)
+        return;
+
+    if (!append) {
+        m_loadingAlbums = false;
+        m_albumOffset = 0;
+        m_albumTotal = 0;
+    }
+
+    m_lastAlbumGenreIds = genreIds;
+    m_lastAlbumType = type;
+    m_loadingAlbums = true;
+    m_backend->getFeaturedAlbums(genreIds, type, 50, static_cast<quint32>(offset));
+}
+
+void GenreBrowserView::requestPlaylistsPage(const QString &genreIds, const QString &type, const QString &tags, const QString &query, int offset, bool append)
+{
+    if (append && m_loadingPlaylists)
+        return;
+
+    if (!append) {
+        m_loadingPlaylists = false;
+        m_playlistOffset = 0;
+        m_playlistTotal = 0;
+        m_loadMorePlaylistsBtn->hide();
+        if (type == QStringLiteral("search"))
+            m_searchViewportFilled = false;
+    }
+
+    m_lastPlaylistGenreIds = genreIds;
+    m_lastPlaylistType = type;
+    m_lastPlaylistTags = tags;
+    m_lastPlaylistQuery = query;
+    m_loadingPlaylists = true;
+
+    if (type == QStringLiteral("search")) {
+        m_backend->searchPlaylists(query, 25, static_cast<quint32>(offset));
+    } else if (type.startsWith(QStringLiteral("discover-"))) {
+        m_backend->discoverPlaylists(genreIds, tags, 25, static_cast<quint32>(offset));
+    } else {
+        m_backend->getFeaturedPlaylists(genreIds, type, 25, static_cast<quint32>(offset));
+    }
+}
+
+void GenreBrowserView::onAlbumScroll(int value)
+{
+    if (m_mode != BrowseMode::Genres)
+        return;
+    if (m_kindCombo->currentData().toString() != QStringLiteral("albums"))
+        return;
+    if (m_loadingAlbums)
+        return;
+    if (m_albumOffset >= m_albumTotal)
+        return;
+
+    QScrollBar *bar = m_albumList->verticalScrollBar();
+    if (!bar || value < (bar->maximum() - 12))
+        return;
+
+    requestAlbumsPage(m_lastAlbumGenreIds, m_lastAlbumType, m_albumOffset, true);
+}
+
+void GenreBrowserView::onPlaylistScroll(int value)
+{
+    // Search results use a manual "Load more" button instead of infinite scroll.
+    if (m_lastPlaylistType == QStringLiteral("search"))
+        return;
+    if (m_loadingPlaylists)
+        return;
+    if (m_playlistOffset >= m_playlistTotal)
+        return;
+
+    QScrollBar *bar = m_playlistList->verticalScrollBar();
+    if (!bar || value < (bar->maximum() - 12))
+        return;
+
+    requestPlaylistsPage(
+        m_lastPlaylistGenreIds,
+        m_lastPlaylistType,
+        m_lastPlaylistTags,
+        m_lastPlaylistQuery,
+        m_playlistOffset,
+        true);
+}
+
+void GenreBrowserView::onDeepShuffleClicked()
+{
+    m_deepShuffleBtn->setEnabled(false);
+    m_deepShuffleBtn->setText(tr("Loading…"));
+
+    if (m_loadingAlbums) {
+        m_collectAlbumsForDeepShuffle = true;
+        return;
+    }
+
+    if (m_albumOffset < m_albumTotal) {
+        m_collectAlbumsForDeepShuffle = true;
+        requestAlbumsPage(m_lastAlbumGenreIds, m_lastAlbumType, m_albumOffset, true);
+        return;
+    }
+
+    startDeepShuffleFromLoadedAlbums();
+}
+
+bool GenreBrowserView::tryHandleDeepShuffleTracks(const QJsonArray &tracks)
+{
+    if (!m_waitingDeepShuffle)
+        return false;
+
+    m_waitingDeepShuffle = false;
+    m_collectAlbumsForDeepShuffle = false;
+    m_deepShuffleBtn->setEnabled(true);
+    m_deepShuffleBtn->setText(tr("⇄  Deep Shuffle"));
+
+    if (tracks.isEmpty())
+        return true;
+
+    m_queue->setContext(tracks, 0);
+    m_queue->shuffleNow();
+    const QJsonObject first = m_queue->current();
+    const qint64 id = static_cast<qint64>(first["id"].toDouble());
+    if (id > 0)
+        emit playTrackRequested(id);
+    return true;
+}
+
+void GenreBrowserView::onAlbumContextMenu(const QPoint &pos)
+{
+    QTreeWidgetItem *item = m_albumList->itemAt(pos);
+    if (!item)
+        return;
+
+    const QString albumId = item->data(1, Qt::UserRole).toString();
+    const qint64 artistId = item->data(2, Qt::UserRole).toLongLong();
+
+    QMenu menu(this);
+
+    auto *openAlbum = menu.addAction(tr("Open Album"));
+    connect(openAlbum, &QAction::triggered, this, [this, albumId] {
+        emit albumSelected(albumId);
+    });
+
+    if (artistId > 0) {
+        auto *openArtist = menu.addAction(tr("Open Artist"));
+        connect(openArtist, &QAction::triggered, this, [this, artistId] {
+            emit artistSelected(artistId);
+        });
+    }
+
+    menu.exec(m_albumList->viewport()->mapToGlobal(pos));
+}
+
+void GenreBrowserView::onPlaylistActivated(QTreeWidgetItem *item, int)
+{
+    if (!item)
+        return;
+
+    const qint64 playlistId = item->data(0, Qt::UserRole).toLongLong();
+    if (playlistId > 0)
+        emit playlistSelected(playlistId);
+}
+
+void GenreBrowserView::onPlaylistContextMenu(const QPoint &pos)
+{
+    QTreeWidgetItem *item = m_playlistList->itemAt(pos);
+    if (!item)
+        return;
+
+    const qint64 playlistId = item->data(0, Qt::UserRole).toLongLong();
+    if (playlistId <= 0)
+        return;
+
+    QMenu menu(this);
+    auto *openPlaylist = menu.addAction(tr("Open Playlist"));
+    connect(openPlaylist, &QAction::triggered, this, [this, playlistId] {
+        emit playlistSelected(playlistId);
+    });
+    menu.exec(m_playlistList->viewport()->mapToGlobal(pos));
+}
+
+void GenreBrowserView::setPlaylistItems(const QJsonArray &items, bool append)
+{
+    if (!append)
+        m_playlistList->clear();
+
+    QFont tagFont;
+    tagFont.setBold(true);
+    tagFont.setPointSizeF(tagFont.pointSizeF() * 0.85);
+
+    for (const auto &value : items) {
+        const QJsonObject playlist = value.toObject();
+        const qint64 playlistId = static_cast<qint64>(playlist["id"].toDouble());
+        const QString name = playlist["name"].toString();
+        const QString owner = playlist["owner"].toObject()["name"].toString();
+        const int tracksCount = playlist["tracks_count"].toInt();
+
+        auto *item = new QTreeWidgetItem(m_playlistList,
+            QStringList{QStringLiteral("P"), name, owner, tracksCount > 0 ? QString::number(tracksCount) : QString()});
+        item->setData(0, Qt::UserRole, playlistId);
+        item->setForeground(0, QColor(QStringLiteral("#2B7CD3")));
+        item->setFont(0, tagFont);
+        item->setTextAlignment(0, Qt::AlignCenter);
+    }
+}
--- a/src/view/genrebrowser.hpp
+++ b/src/view/genrebrowser.hpp
@@ -0,0 +1,104 @@
+#pragma once
+
+#include "../backend/qobuzbackend.hpp"
+#include "../playqueue.hpp"
+#include "albumlistview.hpp"
+
+#include <QComboBox>
+#include <QLabel>
+#include <QLineEdit>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QSet>
+#include <QPushButton>
+#include <QStackedWidget>
+#include <QTreeWidget>
+#include <QWidget>
+#include <QScrollBar>
+
+class GenreBrowserView : public QWidget
+{
+    Q_OBJECT
+
+public:
+    enum class BrowseMode {
+        Genres,
+        PlaylistSearch,
+    };
+
+    explicit GenreBrowserView(QobuzBackend *backend, PlayQueue *queue, QWidget *parent = nullptr);
+
+    void ensureGenresLoaded();
+    void setBrowseMode(BrowseMode mode);
+    bool tryHandleDeepShuffleTracks(const QJsonArray &tracks);
+
+signals:
+    void albumSelected(const QString &albumId);
+    void artistSelected(qint64 artistId);
+    void playlistSelected(qint64 playlistId);
+    void playTrackRequested(qint64 trackId);
+
+private slots:
+    void onGenresLoaded(const QJsonObject &result);
+    void onFeaturedAlbumsLoaded(const QJsonObject &result);
+    void onFeaturedPlaylistsLoaded(const QJsonObject &result);
+    void onDiscoverPlaylistsLoaded(const QJsonObject &result);
+    void onPlaylistSearchLoaded(const QJsonObject &result);
+    void onSelectionChanged();
+    void onAlbumContextMenu(const QPoint &pos);
+    void onPlaylistActivated(QTreeWidgetItem *item, int column);
+    void onPlaylistContextMenu(const QPoint &pos);
+    void onDeepShuffleClicked();
+    void onAlbumScroll(int value);
+    void onPlaylistScroll(int value);
+
+private:
+    QobuzBackend *m_backend = nullptr;
+    PlayQueue *m_queue = nullptr;
+    QLabel *m_browseLabel = nullptr;
+    QLabel *m_genreLabel = nullptr;
+    QLabel *m_typeLabel = nullptr;
+    QLabel *m_playlistSearchLabel = nullptr;
+    QWidget *m_gapAfterKind = nullptr;
+    QWidget *m_gapAfterGenre = nullptr;
+    QComboBox *m_kindCombo = nullptr;
+    QComboBox *m_genreCombo = nullptr;
+    QComboBox *m_typeCombo = nullptr;
+    QLineEdit *m_playlistSearchBox = nullptr;
+    QPushButton *m_playlistSearchBtn = nullptr;
+    QPushButton *m_deepShuffleBtn = nullptr;
+    QStackedWidget *m_resultsStack = nullptr;
+    AlbumListView *m_albumList = nullptr;
+    QTreeWidget *m_playlistList = nullptr;
+    QPushButton *m_loadMorePlaylistsBtn = nullptr;
+    bool m_searchViewportFilled = false;
+    BrowseMode m_mode = BrowseMode::Genres;
+    bool m_genresLoaded = false;
+    int m_lastGenreComboIndex = 0;
+    QSet<qint64> m_multiGenreIds;
+    bool m_waitingDeepShuffle = false;
+    bool m_collectAlbumsForDeepShuffle = false;
+    bool m_loadingAlbums = false;
+    bool m_loadingPlaylists = false;
+    int m_albumOffset = 0;
+    int m_albumTotal = 0;
+    int m_playlistOffset = 0;
+    int m_playlistTotal = 0;
+    QString m_lastAlbumGenreIds;
+    QString m_lastAlbumType;
+    QString m_lastPlaylistGenreIds;
+    QString m_lastPlaylistType;
+    QString m_lastPlaylistTags;
+    QString m_lastPlaylistQuery;
+
+    void refreshModeUi();
+    void refreshGenreTypeChoices();
+    QString currentGenreIds() const;
+    QStringList currentAlbumIds() const;
+    void startDeepShuffleFromLoadedAlbums();
+    void requestAlbumsPage(const QString &genreIds, const QString &type, int offset, bool append);
+    void requestPlaylistsPage(const QString &genreIds, const QString &type, const QString &tags, const QString &query, int offset, bool append);
+    bool chooseMultiGenres();
+    void updateMultiGenreLabel();
+    void setPlaylistItems(const QJsonArray &items, bool append = false);
+};
--- a/src/view/maincontent.cpp
+++ b/src/view/maincontent.cpp
@@ -16,7 +16,7 @@ MainContent::MainContent(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
    m_welcome = new QLabel(
        tr("<h2>Welcome to Qobuz</h2>"
           "<p>Select something from the library on the left to get started,<br>"
-           "or use the search panel (🔍) to find music.</p>"),
+           "or use the search panel to find music.</p>"),
        this);
    m_welcome->setAlignment(Qt::AlignCenter);

@@ -36,68 +36,141 @@ MainContent::MainContent(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
                     [this] { m_tracks->playAll(false); });
    QObject::connect(m_header->shuffleButton(), &QPushButton::clicked,
                     [this] { m_tracks->playAll(true); });
+    QObject::connect(m_header->subtitleButton(), &QPushButton::clicked,
+                     [this] {
+        const qint64 id = m_header->artistId();
+        if (id > 0) emit artistRequested(id);
+    });
+    QObject::connect(m_header->followButton(), &QPushButton::clicked,
+                     [this] {
+        const qint64 id = m_header->playlistId();
+        if (id <= 0 || m_header->playlistOwned())
+            return;
+        emit playlistFollowToggled(id, !m_header->playlistFollowed());
+    });
+    QObject::connect(m_header->favButton(), &QPushButton::clicked,
+                     [this] {
+        const QString albumId = m_header->albumId();
+        if (albumId.isEmpty())
+            return;
+        emit albumFavoriteToggled(albumId, !m_header->albumFaved());
+    });

    m_albumList  = new AlbumListView(this);
    m_artistList = new ArtistListView(this);
-    m_artistView = new ArtistView(this);
+    m_artistView = new ArtistView(backend, queue, this);
+    m_genreBrowser = new GenreBrowserView(backend, queue, this);

-    m_stack->addWidget(m_welcome);    // 0
-    m_stack->addWidget(tracksPage);   // 1
-    m_stack->addWidget(m_albumList);  // 2
-    m_stack->addWidget(m_artistList); // 3
-    m_stack->addWidget(m_artistView); // 4
+    m_stack->addWidget(m_welcome);      // PageWelcome
+    m_stack->addWidget(tracksPage);     // PageTracks
+    m_stack->addWidget(m_albumList);    // PageAlbumList
+    m_stack->addWidget(m_artistList);   // PageArtistList
+    m_stack->addWidget(m_artistView);   // PageArtistDetail
+    m_stack->addWidget(m_genreBrowser); // PageGenreBrowser

-    m_stack->setCurrentIndex(0);
+    m_stack->setCurrentIndex(PageWelcome);

    connect(m_albumList,  &AlbumListView::albumSelected,   this, &MainContent::albumRequested);
    connect(m_artistList, &ArtistListView::artistSelected, this, &MainContent::artistRequested);
    connect(m_artistView, &ArtistView::albumSelected,      this, &MainContent::albumRequested);
+    connect(m_artistView, &ArtistView::playTrackRequested, this, &MainContent::playTrackRequested);
+    connect(m_genreBrowser, &GenreBrowserView::albumSelected, this, &MainContent::albumRequested);
+    connect(m_genreBrowser, &GenreBrowserView::artistSelected, this, &MainContent::artistRequested);
+    connect(m_genreBrowser, &GenreBrowserView::playlistSelected, this, &MainContent::playlistRequested);
+    connect(m_genreBrowser, &GenreBrowserView::playTrackRequested, this, &MainContent::playTrackRequested);
 }

-void MainContent::showWelcome()       { m_stack->setCurrentIndex(0); }
+void MainContent::showWelcome()       { m_stack->setCurrentIndex(PageWelcome); }

 void MainContent::showAlbum(const QJsonObject &album)
 {
-    m_header->setAlbum(album);
+    QString albumId = album["id"].toString();
+    if (albumId.isEmpty() && album["id"].isDouble())
+        albumId = QString::number(static_cast<qint64>(album["id"].toDouble()));
+    m_header->setAlbum(album, m_favAlbumIds.contains(albumId));
    m_tracks->loadAlbum(album);
-    m_stack->setCurrentIndex(1);
+    m_stack->setCurrentIndex(PageTracks);
 }

-void MainContent::showPlaylist(const QJsonObject &playlist)
+void MainContent::showPlaylist(const QJsonObject &playlist, bool isFollowed, bool isOwned)
 {
-    m_header->setPlaylist(playlist);
+    m_header->setPlaylist(playlist, isFollowed, isOwned);
    m_tracks->loadPlaylist(playlist);
-    m_stack->setCurrentIndex(1);
+    m_stack->setCurrentIndex(PageTracks);
 }

 void MainContent::showFavTracks(const QJsonObject &result)
 {
    m_header->hide();
    m_tracks->loadTracks(result["items"].toArray());
-    m_stack->setCurrentIndex(1);
+    m_stack->setCurrentIndex(PageTracks);
 }

 void MainContent::showSearchTracks(const QJsonArray &tracks)
 {
    m_header->hide();
    m_tracks->loadSearchTracks(tracks);
-    m_stack->setCurrentIndex(1);
+    m_stack->setCurrentIndex(PageTracks);
 }

 void MainContent::showFavAlbums(const QJsonObject &result)
 {
    m_albumList->setAlbums(result["items"].toArray());
-    m_stack->setCurrentIndex(2);
+    m_stack->setCurrentIndex(PageAlbumList);
 }

 void MainContent::showFavArtists(const QJsonObject &result)
 {
    m_artistList->setArtists(result["items"].toArray());
-    m_stack->setCurrentIndex(3);
+    m_stack->setCurrentIndex(PageArtistList);
 }

 void MainContent::showArtist(const QJsonObject &artist)
 {
    m_artistView->setArtist(artist);
-    m_stack->setCurrentIndex(4);
+    m_stack->setCurrentIndex(PageArtistDetail);
+}
+
+void MainContent::updateArtistReleases(const QString &releaseType, const QJsonArray &items, bool hasMore, int offset)
+{
+    m_artistView->setReleases(releaseType, items, hasMore, offset);
+}
+
+void MainContent::setFavArtistIds(const QSet<qint64> &ids)
+{
+    m_artistView->setFavArtistIds(ids);
+}
+
+void MainContent::setFavAlbumIds(const QSet<QString> &ids)
+{
+    m_favAlbumIds = ids;
+    const QString shownAlbumId = m_header->albumId();
+    if (!shownAlbumId.isEmpty())
+        m_header->setAlbumFaved(m_favAlbumIds.contains(shownAlbumId));
+}
+
+void MainContent::onDeepShuffleTracks(const QJsonArray &tracks)
+{
+    if (m_genreBrowser->tryHandleDeepShuffleTracks(tracks))
+        return;
+    m_artistView->onDeepShuffleTracks(tracks);
+}
+
+void MainContent::showGenreBrowser()
+{
+    m_genreBrowser->ensureGenresLoaded();
+    m_genreBrowser->setBrowseMode(GenreBrowserView::BrowseMode::Genres);
+    m_stack->setCurrentIndex(PageGenreBrowser);
+}
+
+void MainContent::showPlaylistBrowser()
+{
+    m_genreBrowser->ensureGenresLoaded();
+    m_genreBrowser->setBrowseMode(GenreBrowserView::BrowseMode::PlaylistSearch);
+    m_stack->setCurrentIndex(PageGenreBrowser);
+}
+
+void MainContent::setCurrentPlaylistFollowed(bool followed)
+{
+    m_header->setPlaylistFollowed(followed);
 }
--- a/src/view/maincontent.hpp
+++ b/src/view/maincontent.hpp
@@ -6,6 +6,7 @@
 #include "albumlistview.hpp"
 #include "artistlistview.hpp"
 #include "artistview.hpp"
+#include "genrebrowser.hpp"
 #include "trackcontextheader.hpp"

 #include <QWidget>
@@ -13,6 +14,7 @@
 #include <QStackedWidget>
 #include <QJsonObject>
 #include <QJsonArray>
+#include <QSet>

 class MainContent : public QWidget
 {
@@ -25,18 +27,40 @@ public:

    void showWelcome();
    void showAlbum(const QJsonObject &album);
-    void showPlaylist(const QJsonObject &playlist);
+    void showPlaylist(const QJsonObject &playlist, bool isFollowed, bool isOwned);
    void showFavTracks(const QJsonObject &result);
    void showSearchTracks(const QJsonArray &tracks);
    void showFavAlbums(const QJsonObject &result);
    void showFavArtists(const QJsonObject &result);
    void showArtist(const QJsonObject &artist);
+    void updateArtistReleases(const QString &releaseType, const QJsonArray &items, bool hasMore, int offset);
+    void setFavAlbumIds(const QSet<QString> &ids);
+    void setFavArtistIds(const QSet<qint64> &ids);
+    void onDeepShuffleTracks(const QJsonArray &tracks);
+    void showGenreBrowser();
+    void showPlaylistBrowser();
+    void setCurrentPlaylistFollowed(bool followed);
+
+    ArtistView *artistView() const { return m_artistView; }

 signals:
    void albumRequested(const QString &albumId);
    void artistRequested(qint64 artistId);
+    void albumFavoriteToggled(const QString &albumId, bool favorite);
+    void playlistRequested(qint64 playlistId);
+    void playlistFollowToggled(qint64 playlistId, bool follow);
+    void playTrackRequested(qint64 trackId);

 private:
+    enum StackPage {
+        PageWelcome      = 0,
+        PageTracks       = 1,
+        PageAlbumList    = 2,
+        PageArtistList   = 3,
+        PageArtistDetail = 4,
+        PageGenreBrowser = 5,
+    };
+
    QobuzBackend        *m_backend    = nullptr;
    QStackedWidget      *m_stack      = nullptr;
    QLabel              *m_welcome    = nullptr;
@@ -45,4 +69,6 @@ private:
    AlbumListView       *m_albumList  = nullptr;
    ArtistListView      *m_artistList = nullptr;
    ArtistView          *m_artistView = nullptr;
+    GenreBrowserView    *m_genreBrowser = nullptr;
+    QSet<QString>        m_favAlbumIds;
 };
--- a/src/view/maintoolbar.cpp
+++ b/src/view/maintoolbar.cpp
@@ -4,6 +4,9 @@

 #include <QNetworkRequest>
 #include <QResizeEvent>
+#include <QMenu>
+#include <QDateTime>
+#include <QSignalBlocker>

 MainToolBar::MainToolBar(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
    : QToolBar(parent)
@@ -34,6 +37,22 @@ MainToolBar::MainToolBar(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
    m_trackLabel->setTextFormat(Qt::RichText);
    addWidget(m_trackLabel);

+    m_trackLabel->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(m_trackLabel, &QLabel::customContextMenuRequested,
+            this, [this](const QPoint &pos) {
+        if (m_currentTrack.isEmpty()) return;
+        QMenu menu(this);
+        const QString albumId  = m_currentTrack["album"].toObject()["id"].toString();
+        const qint64  artistId = static_cast<qint64>(
+            m_currentTrack["performer"].toObject()["id"].toDouble());
+        if (!albumId.isEmpty())
+            menu.addAction(tr("Go to Album"),  this, [this, albumId]  { emit albumRequested(albumId);  });
+        if (artistId > 0)
+            menu.addAction(tr("Go to Artist"), this, [this, artistId] { emit artistRequested(artistId); });
+        if (!menu.isEmpty())
+            menu.exec(m_trackLabel->mapToGlobal(pos));
+    });
+
    addSeparator();

    // ---- Media controls ----
@@ -77,11 +96,18 @@ MainToolBar::MainToolBar(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
    m_shuffle->setCheckable(true);
    connect(m_shuffle, &QAction::toggled, this, &MainToolBar::onShuffleToggled);

+    m_autoplay = addAction(Icon::autoplay(), tr("Autoplay"));
+    m_autoplay->setCheckable(true);
+    m_autoplay->setChecked(AppSettings::instance().autoplayEnabled());
+    connect(m_autoplay, &QAction::toggled, this, &MainToolBar::onAutoplayToggled);
+
    // ---- Volume ----
    m_volume = new VolumeButton(this);
-    m_volume->setValue(AppSettings::instance().volume());
    addWidget(m_volume);
    connect(m_volume, &VolumeButton::volumeChanged, this, &MainToolBar::onVolumeChanged);
+    // Set volume after connecting so the backend receives the initial value
+    m_volume->setValue(AppSettings::instance().volume());
+    m_backend->setVolume(AppSettings::instance().volume());

    // ---- Queue toggle ----
    m_queueBtn = addAction(Icon::queue(), tr("Queue"));
@@ -98,6 +124,9 @@ MainToolBar::MainToolBar(QobuzBackend *backend, PlayQueue *queue, QWidget *paren
    connect(m_backend, &QobuzBackend::trackChanged,    this, &MainToolBar::onTrackChanged);
    connect(m_backend, &QobuzBackend::positionChanged, this, &MainToolBar::onPositionChanged);
    connect(m_backend, &QobuzBackend::trackFinished,   this, &MainToolBar::onTrackFinished);
+    connect(m_backend, &QobuzBackend::trackTransitioned, this, &MainToolBar::onTrackTransitioned);
+    connect(m_backend, &QobuzBackend::dynamicSuggestionsLoaded,
+            this, &MainToolBar::onDynamicSuggestionsLoaded);

    // ---- Queue signals ----
    connect(m_queue, &PlayQueue::queueChanged, this, &MainToolBar::onQueueChanged);
@@ -125,6 +154,7 @@ void MainToolBar::setPlaying(bool playing)

 void MainToolBar::setCurrentTrack(const QJsonObject &track)
 {
+    m_currentTrack = track;
    const QString title  = track["title"].toString();
    const QString artist = track["performer"].toObject()["name"].toString().isEmpty()
        ? track["album"].toObject()["artist"].toObject()["name"].toString()
@@ -150,8 +180,8 @@ void MainToolBar::setCurrentTrack(const QJsonObject &track)
 void MainToolBar::updateProgress(quint64 position, quint64 duration)
 {
    if (m_seeking) return;
-    const int sliderPos = duration > 0
-        ? static_cast<int>(position * 1000 / duration) : 0;
+    const int sliderPos = (duration > 0)
+        ? static_cast<int>(qMin(position * 1000 / duration, quint64(1000))) : 0;
    m_progress->blockSignals(true);
    m_progress->setValue(sliderPos);
    m_progress->blockSignals(false);
@@ -161,6 +191,18 @@ void MainToolBar::updateProgress(quint64 position, quint64 duration)
                 TrackListModel::formatDuration(static_cast<qint64>(duration))));
 }

+void MainToolBar::setQueueToggleChecked(bool checked)
+{
+    const QSignalBlocker blocker(m_queueBtn);
+    m_queueBtn->setChecked(checked);
+}
+
+void MainToolBar::setSearchToggleChecked(bool checked)
+{
+    const QSignalBlocker blocker(m_search);
+    m_search->setChecked(checked);
+}
+
 // ---- private slots ----

 void MainToolBar::onPlayPause()
@@ -193,6 +235,10 @@ void MainToolBar::onProgressReleased()
    const quint64 dur = m_backend->duration();
    if (dur > 0) {
        const quint64 target = dur * static_cast<quint64>(m_progress->value()) / 1000;
+        m_seekPending = true;
+        m_pendingSeekTarget = target;
+        m_pendingSeekStartedMs = QDateTime::currentMSecsSinceEpoch();
+        updateProgress(target, dur);
        m_backend->seek(target);
    }
 }
@@ -210,11 +256,40 @@ void MainToolBar::onBackendStateChanged(const QString &state)

 void MainToolBar::onTrackChanged(const QJsonObject &track)
 {
+    m_seekPending = false;
+    m_seeking = false;
    setCurrentTrack(track);
+
+    const qint64 trackId = static_cast<qint64>(track["id"].toDouble());
+    if (trackId <= 0)
+        return;
+
+    const qint64 artistId = static_cast<qint64>(
+        track["performer"].toObject()["id"].toDouble());
+    const qint64 genreId = static_cast<qint64>(
+        track["album"].toObject()["genre"].toObject()["id"].toDouble());
+    const qint64 labelId = static_cast<qint64>(
+        track["album"].toObject()["label"].toObject()["id"].toDouble());
+
+    m_recentTracks.append(RecentTrackSeed{trackId, artistId, genreId, labelId});
+    while (m_recentTracks.size() > 32)
+        m_recentTracks.removeFirst();
 }

 void MainToolBar::onPositionChanged(quint64 position, quint64 duration)
 {
+    if (m_seekPending) {
+        const qint64 nowMs = QDateTime::currentMSecsSinceEpoch();
+        const quint64 delta = (position > m_pendingSeekTarget)
+            ? (position - m_pendingSeekTarget)
+            : (m_pendingSeekTarget - position);
+
+        if (delta > 2 && (nowMs - m_pendingSeekStartedMs) < 1500)
+            return;
+
+        m_seekPending = false;
+    }
+
    updateProgress(position, duration);
 }

@@ -222,6 +297,8 @@ void MainToolBar::onTrackFinished()
 {
    if (m_queue->canGoNext()) {
        onNext();
+    } else if (AppSettings::instance().autoplayEnabled()) {
+        requestAutoplaySuggestions();
    } else {
        setPlaying(false);
        m_progress->setValue(0);
@@ -229,6 +306,17 @@ void MainToolBar::onTrackFinished()
    }
 }

+void MainToolBar::onTrackTransitioned()
+{
+    if (m_queue->canGoNext()) {
+        const QJsonObject track = m_queue->advance();
+        setCurrentTrack(track);
+        m_backend->manuallyEmitTrackChanged(track);
+    } else {
+        onTrackFinished();
+    }
+}
+
 void MainToolBar::onQueueChanged()
 {
    m_previous->setEnabled(m_queue->canGoPrev());
@@ -240,6 +328,71 @@ void MainToolBar::onShuffleToggled(bool checked)
    m_queue->setShuffle(checked);
 }

+void MainToolBar::onAutoplayToggled(bool checked)
+{
+    AppSettings::instance().setAutoplayEnabled(checked);
+}
+
+void MainToolBar::requestAutoplaySuggestions()
+{
+    if (m_fetchingAutoplay)
+        return;
+
+    QJsonArray listenedIds;
+    QJsonArray analyze;
+
+    const int n = m_recentTracks.size();
+    for (int i = 0; i < n; ++i) {
+        const RecentTrackSeed &t = m_recentTracks.at(i);
+
+        listenedIds.append(t.trackId);
+
+        if (i < qMax(0, n - 5))
+            continue;
+
+        analyze.append(QJsonObject{
+            {"track_id", t.trackId},
+            {"artist_id", t.artistId},
+            {"genre_id", t.genreId},
+            {"label_id", t.labelId},
+        });
+    }
+
+    if (listenedIds.isEmpty() || analyze.isEmpty()) {
+        setPlaying(false);
+        m_progress->setValue(0);
+        m_position->setText(QStringLiteral("0:00 / 0:00"));
+        return;
+    }
+
+    m_fetchingAutoplay = true;
+    m_backend->getDynamicSuggestions(listenedIds, analyze, 50);
+}
+
+void MainToolBar::onDynamicSuggestionsLoaded(const QJsonObject &result)
+{
+    m_fetchingAutoplay = false;
+
+    QJsonArray items;
+    if (result["tracks"].isObject())
+        items = result["tracks"].toObject()["items"].toArray();
+    if (items.isEmpty() && result["dynamic"].isObject())
+        items = result["dynamic"].toObject()["items"].toArray();
+    if (items.isEmpty())
+        items = result["items"].toArray();
+
+    if (items.isEmpty()) {
+        setPlaying(false);
+        m_progress->setValue(0);
+        m_position->setText(QStringLiteral("0:00 / 0:00"));
+        return;
+    }
+
+    m_queue->appendToContext(items);
+    if (m_queue->canGoNext())
+        onNext();
+}
+
 void MainToolBar::fetchAlbumArt(const QString &url)
 {
    m_nam->get(QNetworkRequest(QUrl(url)));
--- a/src/view/maintoolbar.hpp
+++ b/src/view/maintoolbar.hpp
@@ -12,6 +12,7 @@
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 #include <QJsonObject>
+#include <QVector>

 class MainToolBar : public QToolBar
 {
@@ -23,10 +24,14 @@ public:
    void setPlaying(bool playing);
    void setCurrentTrack(const QJsonObject &track);
    void updateProgress(quint64 position, quint64 duration);
+    void setQueueToggleChecked(bool checked);
+    void setSearchToggleChecked(bool checked);

 signals:
    void searchToggled(bool visible);
    void queueToggled(bool visible);
+    void albumRequested(const QString &albumId);
+    void artistRequested(qint64 artistId);

 protected:
    void resizeEvent(QResizeEvent *event) override;
@@ -42,13 +47,23 @@ private slots:
    void onTrackChanged(const QJsonObject &track);
    void onPositionChanged(quint64 position, quint64 duration);
    void onTrackFinished();
+    void onTrackTransitioned();
    void onQueueChanged();
    void onShuffleToggled(bool checked);
+    void onAutoplayToggled(bool checked);
+    void onDynamicSuggestionsLoaded(const QJsonObject &result);

    void fetchAlbumArt(const QString &url);
    void onAlbumArtReady(QNetworkReply *reply);

 private:
+    struct RecentTrackSeed {
+        qint64 trackId = 0;
+        qint64 artistId = 0;
+        qint64 genreId = 0;
+        qint64 labelId = 0;
+    };
+
    QobuzBackend *m_backend = nullptr;
    PlayQueue    *m_queue   = nullptr;

@@ -62,12 +77,21 @@ private:
    QLabel          *m_position    = nullptr;
    QWidget         *m_rightSpacer = nullptr;
    QAction         *m_shuffle     = nullptr;
+    QAction         *m_autoplay    = nullptr;
    VolumeButton    *m_volume      = nullptr;
    QAction         *m_queueBtn    = nullptr;
    QAction         *m_search      = nullptr;

    QNetworkAccessManager *m_nam = nullptr;
    QString     m_currentArtUrl;
+    QJsonObject m_currentTrack;
+    QVector<RecentTrackSeed> m_recentTracks;
    bool        m_playing = false;
    bool        m_seeking = false;
+    bool        m_seekPending = false;
+    quint64     m_pendingSeekTarget = 0;
+    qint64      m_pendingSeekStartedMs = 0;
+    bool        m_fetchingAutoplay = false;
+
+    void requestAutoplaySuggestions();
 };
--- a/src/view/queuepanel.cpp
+++ b/src/view/queuepanel.cpp
@@ -10,9 +10,8 @@

 static constexpr int UpcomingIndexRole = Qt::UserRole + 1;
 static constexpr int IsPlayNextRole    = Qt::UserRole + 2;
-static constexpr int TrackJsonRole     = Qt::UserRole + 3;
-static constexpr int ArtistRole        = Qt::UserRole + 4;
-static constexpr int DurationRole      = Qt::UserRole + 5;
+static constexpr int ArtistRole        = Qt::UserRole + 3;
+static constexpr int DurationRole      = Qt::UserRole + 4;

 // ---- Custom delegate -------------------------------------------------------

@@ -173,7 +172,9 @@ void QueuePanel::refresh()

    for (int i = 0; i < upcoming.size(); ++i) {
        const QJsonObject &t = upcoming.at(i);
-        const QString title  = t["title"].toString();
+        const QString base    = t["title"].toString();
+        const QString ver     = t["version"].toString().trimmed();
+        const QString title   = ver.isEmpty() ? base : base + QStringLiteral(" (") + ver + QLatin1Char(')');
        const QString artist = t["performer"].toObject()["name"].toString().isEmpty()
            ? t["album"].toObject()["artist"].toObject()["name"].toString()
            : t["performer"].toObject()["name"].toString();
@@ -182,7 +183,6 @@ void QueuePanel::refresh()
        auto *item = new QListWidgetItem(title, m_list);
        item->setData(UpcomingIndexRole, i);
        item->setData(IsPlayNextRole, i < playNextCount);
-        item->setData(TrackJsonRole, QVariant::fromValue(t));
        item->setData(ArtistRole, artist);
        item->setData(DurationRole, duration);
    }
@@ -203,10 +203,14 @@ void QueuePanel::onRowsMoved()
 {
    if (m_refreshing) return;

+    const QVector<QJsonObject> currentUpcoming = m_queue->upcomingTracks();
    QVector<QJsonObject> newOrder;
    newOrder.reserve(m_list->count());
-    for (int i = 0; i < m_list->count(); ++i)
-        newOrder.append(m_list->item(i)->data(TrackJsonRole).value<QJsonObject>());
+    for (int i = 0; i < m_list->count(); ++i) {
+        const int prevIndex = m_list->item(i)->data(UpcomingIndexRole).toInt();
+        if (prevIndex >= 0 && prevIndex < currentUpcoming.size())
+            newOrder.append(currentUpcoming.at(prevIndex));
+    }

    m_refreshing = true;
    m_queue->setUpcomingOrder(newOrder);
--- a/src/view/sidepanel/view.cpp
+++ b/src/view/sidepanel/view.cpp
@@ -1,4 +1,5 @@
 #include "view.hpp"
+#include "../../util/trackinfo.hpp"

 #include <QVBoxLayout>
 #include <QHBoxLayout>
@@ -6,18 +7,21 @@
 #include <QHeaderView>
 #include <QFont>
 #include <QJsonArray>
+#include <QMenu>

 static constexpr int IdRole   = Qt::UserRole + 1;
 static constexpr int TypeRole = Qt::UserRole + 2;
+static constexpr int JsonRole = Qt::UserRole + 3;

 namespace SidePanel
 {

 // ---- SearchTab ----

-SearchTab::SearchTab(QobuzBackend *backend, QWidget *parent)
+SearchTab::SearchTab(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
    : QWidget(parent)
    , m_backend(backend)
+    , m_queue(queue)
 {
    auto *layout = new QVBoxLayout(this);
    layout->setContentsMargins(4, 4, 4, 4);
@@ -25,7 +29,7 @@ SearchTab::SearchTab(QobuzBackend *backend, QWidget *parent)
    // Search bar
    auto *barLayout = new QHBoxLayout;
    m_searchBox     = new QLineEdit(this);
-    m_searchBox->setPlaceholderText(tr("Search Qobuz…"));
+    m_searchBox->setPlaceholderText(tr("Search Qobuz..."));
    m_searchBox->setClearButtonEnabled(true);
    auto *searchBtn = new QPushButton(tr("Go"), this);
    barLayout->addWidget(m_searchBox);
@@ -35,9 +39,18 @@ SearchTab::SearchTab(QobuzBackend *backend, QWidget *parent)
    // Result tabs
    m_resultTabs = new QTabWidget(this);

+    m_topResults = new QTreeWidget(this);
+    m_topResults->setHeaderLabels({tr(""), tr("Top Result"), tr("Info")});
+    m_topResults->setRootIsDecorated(false);
+    m_topResults->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
+    m_topResults->header()->setSectionResizeMode(1, QHeaderView::Stretch);
+    m_topResults->header()->setSectionResizeMode(2, QHeaderView::Stretch);
+    m_topResults->header()->setStretchLastSection(false);
+
    m_trackResults  = new QTreeWidget(this);
    m_trackResults->setHeaderLabels({tr("Title"), tr("Artist"), tr("Album")});
    m_trackResults->setRootIsDecorated(false);
+    m_trackResults->setContextMenuPolicy(Qt::CustomContextMenu);

    m_albumResults  = new QTreeWidget(this);
    m_albumResults->setHeaderLabels({tr(""), tr("Album"), tr("Artist")});
@@ -46,11 +59,13 @@ SearchTab::SearchTab(QobuzBackend *backend, QWidget *parent)
    m_albumResults->header()->setSectionResizeMode(1, QHeaderView::Stretch);
    m_albumResults->header()->setSectionResizeMode(2, QHeaderView::Stretch);
    m_albumResults->header()->setStretchLastSection(false);
+    m_albumResults->setContextMenuPolicy(Qt::CustomContextMenu);

    m_artistResults = new QTreeWidget(this);
    m_artistResults->setHeaderLabels({tr("Artist")});
    m_artistResults->setRootIsDecorated(false);

+    m_resultTabs->addTab(m_topResults, tr("Top Results"));
    m_resultTabs->addTab(m_trackResults,  tr("Tracks"));
    m_resultTabs->addTab(m_albumResults,  tr("Albums"));
    m_resultTabs->addTab(m_artistResults, tr("Artists"));
@@ -60,17 +75,89 @@ SearchTab::SearchTab(QobuzBackend *backend, QWidget *parent)
    connect(m_searchBox, &QLineEdit::returnPressed, this, &SearchTab::onSearchSubmit);

    connect(m_backend, &QobuzBackend::searchResult, this, &SearchTab::onSearchResult);
+    connect(m_backend, &QobuzBackend::mostPopularResult, this, &SearchTab::onMostPopularResult);

+    connect(m_topResults,   &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
    connect(m_trackResults,  &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
    connect(m_albumResults,  &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
    connect(m_artistResults, &QTreeWidget::itemDoubleClicked, this, &SearchTab::onItemDoubleClicked);
+
+    // Context menus
+    connect(m_trackResults, &QTreeWidget::customContextMenuRequested,
+            this, &SearchTab::onTrackContextMenu);
+    connect(m_albumResults, &QTreeWidget::customContextMenuRequested,
+            this, &SearchTab::onAlbumContextMenu);
+}
+
+void SearchTab::setUserPlaylists(const QVector<QPair<qint64, QString>> &playlists)
+{
+    m_userPlaylists = playlists;
 }

 void SearchTab::onSearchSubmit()
 {
    const QString q = m_searchBox->text().trimmed();
-    if (!q.isEmpty())
+    if (!q.isEmpty()) {
+        m_backend->mostPopularSearch(q, 8);
        m_backend->search(q, 0, 20);
+        m_resultTabs->setCurrentIndex(0);
+    }
+}
+
+void SearchTab::onMostPopularResult(const QJsonObject &result)
+{
+    m_topResults->clear();
+
+    QFont badgeFont;
+    badgeFont.setBold(true);
+
+    const QJsonArray items = result["most_popular"].toObject()["items"].toArray();
+    for (const auto &value : items) {
+        const QJsonObject itemObj = value.toObject();
+        const QString type = itemObj["type"].toString();
+        const QJsonObject content = itemObj["content"].toObject();
+
+        auto *item = new QTreeWidgetItem(m_topResults);
+        item->setData(0, JsonRole, content);
+
+        if (type == QStringLiteral("tracks")) {
+            const QString title = content["title"].toString();
+            const QString artist = content["performer"].toObject()["name"].toString();
+            const QString album = content["album"].toObject()["title"].toString();
+            item->setText(0, QStringLiteral("T"));
+            item->setForeground(0, QColor(QStringLiteral("#2FA84F")));
+            item->setFont(0, badgeFont);
+            item->setTextAlignment(0, Qt::AlignCenter);
+            item->setText(1, title);
+            item->setText(2, artist.isEmpty() ? album : QStringLiteral("%1 - %2").arg(artist, album));
+            item->setData(0, TypeRole, QStringLiteral("track"));
+            item->setData(0, IdRole, static_cast<qint64>(content["id"].toDouble()));
+        } else if (type == QStringLiteral("albums")) {
+            const QString title = content["title"].toString();
+            const QString artist = content["artist"].toObject()["name"].toString();
+            const bool hiRes = content["hires_streamable"].toBool()
+                || content["rights"].toObject()["hires_streamable"].toBool();
+            item->setText(0, hiRes ? QStringLiteral("H") : QStringLiteral("A"));
+            item->setForeground(0, hiRes
+                ? QColor(QStringLiteral("#FFB232"))
+                : QColor(QStringLiteral("#8E8E93")));
+            item->setFont(0, badgeFont);
+            item->setTextAlignment(0, Qt::AlignCenter);
+            item->setText(1, title);
+            item->setText(2, artist);
+            item->setData(0, TypeRole, QStringLiteral("album"));
+            item->setData(1, IdRole, content["id"].toString());
+        } else if (type == QStringLiteral("artists")) {
+            item->setText(0, QStringLiteral("A"));
+            item->setForeground(0, QColor(QStringLiteral("#2B7CD3")));
+            item->setFont(0, badgeFont);
+            item->setTextAlignment(0, Qt::AlignCenter);
+            item->setText(1, content["name"].toString());
+            item->setText(2, tr("Artist"));
+            item->setData(0, TypeRole, QStringLiteral("artist"));
+            item->setData(0, IdRole, static_cast<qint64>(content["id"].toDouble()));
+        }
+    }
 }

 void SearchTab::onSearchResult(const QJsonObject &result)
@@ -86,6 +173,7 @@ void SearchTab::onSearchResult(const QJsonObject &result)
            QStringList{t["title"].toString(), performer, album});
        item->setData(0, IdRole,   static_cast<qint64>(t["id"].toDouble()));
        item->setData(0, TypeRole, QStringLiteral("track"));
+        item->setData(0, JsonRole, t);
    }

    // Populate albums
@@ -109,8 +197,9 @@ void SearchTab::onSearchResult(const QJsonObject &result)
                item->setFont(0, hiResFont);
                item->setTextAlignment(0, Qt::AlignCenter);
            }
-            item->setData(0, TypeRole, QStringLiteral("album")); // handler reads col 0
+            item->setData(0, TypeRole, QStringLiteral("album"));
            item->setData(1, IdRole,   a["id"].toString());
+            item->setData(0, JsonRole, a);
        }
    }

@@ -140,20 +229,135 @@ void SearchTab::onItemDoubleClicked(QTreeWidgetItem *item, int)
    }
 }

+void SearchTab::onTrackContextMenu(const QPoint &pos)
+{
+    auto *item = m_trackResults->itemAt(pos);
+    if (!item) return;
+
+    const qint64 trackId = item->data(0, IdRole).toLongLong();
+    const QJsonObject trackJson = item->data(0, JsonRole).toJsonObject();
+    if (trackId <= 0) return;
+
+    QMenu menu(this);
+
+    auto *playNow  = menu.addAction(tr("Play now"));
+    auto *playNext = menu.addAction(tr("Play next"));
+    auto *addQueue = menu.addAction(tr("Add to queue"));
+    menu.addSeparator();
+
+    auto *addFav = menu.addAction(tr("Add to favorites"));
+
+    // Open album / artist
+    const QString albumId = trackJson["album"].toObject()["id"].toString();
+    const qint64 artistId = static_cast<qint64>(
+        trackJson["performer"].toObject()["id"].toDouble());
+    const QString artistName = trackJson["performer"].toObject()["name"].toString();
+    const QString albumTitle = trackJson["album"].toObject()["title"].toString();
+
+    menu.addSeparator();
+    if (!albumId.isEmpty()) {
+        auto *openAlbum = menu.addAction(tr("Go to album: %1").arg(QString(albumTitle).replace(QLatin1Char('&'), QStringLiteral("&&"))));
+        connect(openAlbum, &QAction::triggered, this, [this, albumId] {
+            emit albumSelected(albumId);
+        });
+    }
+    if (artistId > 0) {
+        auto *openArtist = menu.addAction(tr("Go to artist: %1").arg(QString(artistName).replace(QLatin1Char('&'), QStringLiteral("&&"))));
+        connect(openArtist, &QAction::triggered, this, [this, artistId] {
+            emit artistSelected(artistId);
+        });
+    }
+
+    // Add to playlist submenu
+    if (!m_userPlaylists.isEmpty()) {
+        menu.addSeparator();
+        auto *plMenu = menu.addMenu(tr("Add to playlist"));
+        for (const auto &pl : m_userPlaylists) {
+            auto *act = plMenu->addAction(pl.second);
+            connect(act, &QAction::triggered, this, [this, trackId, plId = pl.first] {
+                emit addToPlaylistRequested(trackId, plId);
+            });
+        }
+    }
+
+    // Track info
+    menu.addSeparator();
+    auto *info = menu.addAction(tr("Track info..."));
+
+    connect(playNow, &QAction::triggered, this, [this, trackId] {
+        emit trackPlayRequested(trackId);
+    });
+    connect(playNext, &QAction::triggered, this, [this, trackJson] {
+        m_queue->playNext(trackJson);
+    });
+    connect(addQueue, &QAction::triggered, this, [this, trackJson] {
+        m_queue->addToQueue(trackJson);
+    });
+    connect(addFav, &QAction::triggered, this, [this, trackId] {
+        m_backend->addFavTrack(trackId);
+    });
+    connect(info, &QAction::triggered, this, [this, trackJson] {
+        showTrackInfo(trackJson);
+    });
+
+    menu.exec(m_trackResults->viewport()->mapToGlobal(pos));
+}
+
+void SearchTab::onAlbumContextMenu(const QPoint &pos)
+{
+    auto *item = m_albumResults->itemAt(pos);
+    if (!item) return;
+
+    const QString albumId = item->data(1, IdRole).toString();
+    const QJsonObject albumJson = item->data(0, JsonRole).toJsonObject();
+    if (albumId.isEmpty()) return;
+
+    QMenu menu(this);
+
+    auto *openAlbum = menu.addAction(tr("Open album"));
+    auto *addFav    = menu.addAction(tr("Add to favorites"));
+
+    const qint64 artistId = static_cast<qint64>(
+        albumJson["artist"].toObject()["id"].toDouble());
+    const QString artistName = albumJson["artist"].toObject()["name"].toString();
+    if (artistId > 0) {
+        menu.addSeparator();
+        auto *openArtist = menu.addAction(tr("Go to artist: %1").arg(QString(artistName).replace(QLatin1Char('&'), QStringLiteral("&&"))));
+        connect(openArtist, &QAction::triggered, this, [this, artistId] {
+            emit artistSelected(artistId);
+        });
+    }
+
+    connect(openAlbum, &QAction::triggered, this, [this, albumId] {
+        emit albumSelected(albumId);
+    });
+    connect(addFav, &QAction::triggered, this, [this, albumId] {
+        m_backend->addFavAlbum(albumId);
+    });
+
+    menu.exec(m_albumResults->viewport()->mapToGlobal(pos));
+}
+
+void SearchTab::showTrackInfo(const QJsonObject &track)
+{
+    TrackInfoDialog::show(track, this);
+}
+
 // ---- View ----

-View::View(QobuzBackend *backend, QWidget *parent)
+View::View(QobuzBackend *backend, PlayQueue *queue, QWidget *parent)
    : QDockWidget(tr("Search"), parent)
 {
    setObjectName(QStringLiteral("searchPanel"));
    setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetClosable);

-    m_search = new SearchTab(backend, this);
+    m_search = new SearchTab(backend, queue, this);
    setWidget(m_search);

    connect(m_search, &SearchTab::albumSelected,           this, &View::albumSelected);
    connect(m_search, &SearchTab::artistSelected,          this, &View::artistSelected);
    connect(m_search, &SearchTab::trackPlayRequested,      this, &View::trackPlayRequested);
+    connect(m_search, &SearchTab::addToPlaylistRequested,  this, &View::addToPlaylistRequested);
 }

 } // namespace SidePanel
--- a/src/view/sidepanel/view.hpp
+++ b/src/view/sidepanel/view.hpp
@@ -1,6 +1,7 @@
 #pragma once

 #include "../../backend/qobuzbackend.hpp"
+#include "../../playqueue.hpp"

 #include <QWidget>
 #include <QDockWidget>
@@ -8,6 +9,8 @@
 #include <QLineEdit>
 #include <QTreeWidget>
 #include <QJsonObject>
+#include <QVector>
+#include <QPair>

 namespace SidePanel
 {
@@ -15,32 +18,43 @@ namespace SidePanel
    {
        Q_OBJECT
    public:
-        explicit SearchTab(QobuzBackend *backend, QWidget *parent = nullptr);
+        explicit SearchTab(QobuzBackend *backend, PlayQueue *queue, QWidget *parent = nullptr);
+
+        void setUserPlaylists(const QVector<QPair<qint64, QString>> &playlists);

    signals:
        void albumSelected(const QString &albumId);
        void artistSelected(qint64 artistId);
        void trackPlayRequested(qint64 trackId);
+        void addToPlaylistRequested(qint64 trackId, qint64 playlistId);

    private slots:
        void onSearchResult(const QJsonObject &result);
+        void onMostPopularResult(const QJsonObject &result);
        void onSearchSubmit();
        void onItemDoubleClicked(QTreeWidgetItem *item, int column);

    private:
        QobuzBackend *m_backend    = nullptr;
+        PlayQueue    *m_queue      = nullptr;
        QLineEdit    *m_searchBox  = nullptr;
        QTabWidget   *m_resultTabs = nullptr;
+        QTreeWidget  *m_topResults = nullptr;
        QTreeWidget  *m_trackResults  = nullptr;
        QTreeWidget  *m_albumResults  = nullptr;
        QTreeWidget  *m_artistResults = nullptr;
+        QVector<QPair<qint64, QString>> m_userPlaylists;
+
+        void onTrackContextMenu(const QPoint &pos);
+        void onAlbumContextMenu(const QPoint &pos);
+        void showTrackInfo(const QJsonObject &track);
    };

    class View : public QDockWidget
    {
        Q_OBJECT
    public:
-        explicit View(QobuzBackend *backend, QWidget *parent = nullptr);
+        explicit View(QobuzBackend *backend, PlayQueue *queue, QWidget *parent = nullptr);

        SearchTab *searchTab() const { return m_search; }

@@ -48,6 +62,7 @@ namespace SidePanel
        void albumSelected(const QString &albumId);
        void artistSelected(qint64 artistId);
        void trackPlayRequested(qint64 trackId);
+        void addToPlaylistRequested(qint64 trackId, qint64 playlistId);

    private:
        SearchTab *m_search = nullptr;
--- a/src/view/trackcontextheader.hpp
+++ b/src/view/trackcontextheader.hpp
@@ -49,11 +49,16 @@ public:
        m_title->setWordWrap(true);
        vlay->addWidget(m_title);

-        m_subtitle = new QLabel(info);
+        m_subtitle = new QPushButton(info);
+        m_subtitle->setFlat(true);
+        m_subtitle->setStyleSheet(QStringLiteral(
+            "QPushButton { border: none; background: none; text-align: left; padding: 0; margin: 0; }"
+            "QPushButton:enabled:hover { color: #FFB232; }"
+            "QPushButton:!enabled { color: palette(text); }"
+        ));
        QFont sf = m_subtitle->font();
        sf.setPointSize(sf.pointSize() + 1);
        m_subtitle->setFont(sf);
-        m_subtitle->setWordWrap(true);
        vlay->addWidget(m_subtitle);

        m_meta = new QLabel(info);
@@ -88,8 +93,23 @@ public:
                           "QPushButton:pressed { background: #333; }"));
        btnRow->addWidget(m_shuffleBtn);

+        m_favBtn = new QPushButton(tr("♡  Favourite"), info);
+        m_favBtn->setStyleSheet(btnBase +
+            QStringLiteral("QPushButton { background: #2a2a2a; color: #ccc; border: 1px solid #555; }"
+                           "QPushButton:pressed { background: #333; }"));
+        m_favBtn->hide();
+        btnRow->addWidget(m_favBtn);
+
+        m_followBtn = new QPushButton(tr("Follow"), info);
+        m_followBtn->setStyleSheet(btnBase +
+            QStringLiteral("QPushButton { background: #2a2a2a; color: #ddd; border: 1px solid #666; }"
+                           "QPushButton:pressed { background: #333; }"));
+        m_followBtn->hide();
+        btnRow->addWidget(m_followBtn);
+
        btnRow->addStretch();
        vlay->addLayout(btnRow);
+        vlay->addStretch(1);

        hlay->addWidget(info, 1);

@@ -107,24 +127,71 @@ public:

    QPushButton *playButton()    { return m_playBtn; }
    QPushButton *shuffleButton() { return m_shuffleBtn; }
+    QPushButton *favButton()     { return m_favBtn; }
+    QPushButton *followButton()  { return m_followBtn; }

-    void setAlbum(const QJsonObject &album)
+    QPushButton *subtitleButton() { return m_subtitle; }
+    QString albumId() const      { return m_albumId; }
+    bool albumFaved() const      { return m_albumFaved; }
+    qint64 artistId() const      { return m_artistId; }
+    qint64 playlistId() const    { return m_playlistId; }
+    bool playlistFollowed() const { return m_playlistFollowed; }
+    bool playlistOwned() const    { return m_playlistOwned; }
+
+    void setAlbum(const QJsonObject &album, bool isFaved)
    {
-        m_title->setText(album["title"].toString());
+        const QString base = album["title"].toString();
+        const QString ver  = album["version"].toString().trimmed();
+        m_title->setText(ver.isEmpty() ? base : base + QStringLiteral(" (") + ver + QLatin1Char(')'));
+        m_albumId = album["id"].toString();
+        if (m_albumId.isEmpty() && album["id"].isDouble())
+            m_albumId = QString::number(static_cast<qint64>(album["id"].toDouble()));
+        m_artistId = static_cast<qint64>(album["artist"].toObject()["id"].toDouble());
        m_subtitle->setText(album["artist"].toObject()["name"].toString());
+        m_subtitle->setEnabled(m_artistId > 0);
+        m_subtitle->setCursor(m_artistId > 0 ? Qt::PointingHandCursor : Qt::ArrowCursor);
        m_meta->setText(buildAlbumMeta(album));
+
+        setAlbumFaved(isFaved);
+        m_favBtn->setEnabled(!m_albumId.isEmpty());
+        m_favBtn->show();
+
+        m_followBtn->hide();
+        m_playlistId = 0;
+        m_playlistFollowed = false;
+        m_playlistOwned = false;
        fetchArt(album["image"].toObject());
        show();
    }

-    void setPlaylist(const QJsonObject &playlist)
+    void setPlaylist(const QJsonObject &playlist, bool isFollowed, bool isOwned)
    {
        m_title->setText(playlist["name"].toString());
+        m_artistId = 0;
+        m_playlistId = static_cast<qint64>(playlist["id"].toDouble());
+        m_playlistFollowed = isFollowed;
+        m_playlistOwned = isOwned;
        const QString desc  = playlist["description"].toString();
        const QString owner = playlist["owner"].toObject()["name"].toString();
        m_subtitle->setText(desc.isEmpty() ? owner : desc);
+        m_subtitle->setEnabled(false);
+        m_subtitle->setCursor(Qt::ArrowCursor);
        m_meta->setText(buildPlaylistMeta(playlist));

+        m_albumId.clear();
+        m_albumFaved = false;
+        m_favBtn->hide();
+
+        if (m_playlistOwned) {
+            m_followBtn->setText(tr("Owned"));
+            m_followBtn->setEnabled(false);
+            m_followBtn->show();
+        } else {
+            m_followBtn->setText(m_playlistFollowed ? tr("Unfollow") : tr("Follow"));
+            m_followBtn->setEnabled(m_playlistId > 0);
+            m_followBtn->show();
+        }
+
        // Try images300 → images150 → images (API returns mosaic arrays, not image_rectangle)
        const QJsonArray imgs300 = playlist["images300"].toArray();
        const QJsonArray imgs150 = playlist["images150"].toArray();
@@ -139,6 +206,31 @@ public:
        show();
    }

+    void setPlaylistFollowed(bool followed)
+    {
+        m_playlistFollowed = followed;
+        if (!m_playlistOwned)
+            m_followBtn->setText(m_playlistFollowed ? tr("Unfollow") : tr("Follow"));
+    }
+
+    void setAlbumFaved(bool faved)
+    {
+        m_albumFaved = faved;
+        if (faved) {
+            m_favBtn->setText(tr("♥  Favourited"));
+            m_favBtn->setStyleSheet(QStringLiteral(
+                "QPushButton { padding: 5px 16px; border-radius: 4px; font-weight: bold;"
+                "  background: #2a2a2a; color: #FFB232; border: 1px solid #FFB232; }"
+                "QPushButton:pressed { background: #333; }"));
+        } else {
+            m_favBtn->setText(tr("♡  Favourite"));
+            m_favBtn->setStyleSheet(QStringLiteral(
+                "QPushButton { padding: 5px 16px; border-radius: 4px; font-weight: bold;"
+                "  background: #2a2a2a; color: #ccc; border: 1px solid #555; }"
+                "QPushButton:pressed { background: #333; }"));
+        }
+    }
+
 private:
    void fetchArt(const QJsonObject &img)
    {
@@ -200,10 +292,18 @@ private:

    QLabel                *m_art        = nullptr;
    QLabel                *m_title      = nullptr;
-    QLabel                *m_subtitle   = nullptr;
+    QPushButton           *m_subtitle   = nullptr;
    QLabel                *m_meta       = nullptr;
    QPushButton           *m_playBtn    = nullptr;
    QPushButton           *m_shuffleBtn = nullptr;
+    QPushButton           *m_favBtn     = nullptr;
+    QPushButton           *m_followBtn  = nullptr;
    QNetworkAccessManager *m_nam        = nullptr;
    QString                m_currentArtUrl;
+    QString                m_albumId;
+    bool                   m_albumFaved = false;
+    qint64                 m_artistId   = 0;
+    qint64                 m_playlistId = 0;
+    bool                   m_playlistFollowed = false;
+    bool                   m_playlistOwned = false;
 };
--- a/src/widget/volumebutton.hpp
+++ b/src/widget/volumebutton.hpp
@@ -4,10 +4,9 @@
 #include "../util/icon.hpp"

 #include <QToolButton>
-#include <QWidgetAction>
-#include <QMenu>
-#include <QLabel>
+#include <QFrame>
 #include <QVBoxLayout>
+#include <QLabel>

 /// A toolbar button that shows a volume slider popup when clicked.
 class VolumeButton : public QToolButton
@@ -17,33 +16,36 @@ class VolumeButton : public QToolButton
 public:
    explicit VolumeButton(QWidget *parent = nullptr) : QToolButton(parent)
    {
-        setPopupMode(QToolButton::InstantPopup);
        setIcon(Icon::volumeHigh());

-        auto *menu   = new QMenu(this);
-        auto *widget = new QWidget(menu);
-        widget->setMinimumWidth(72);
-        auto *layout = new QVBoxLayout(widget);
-        layout->setContentsMargins(6, 6, 6, 6);
+        // Qt::Popup closes automatically when the user clicks outside.
+        m_popup = new QFrame(this, Qt::Popup);
+        m_popup->setFrameShape(QFrame::StyledPanel);
+        m_popup->setFrameShadow(QFrame::Raised);

-        m_label  = new QLabel("80%", widget);
+        auto *layout = new QVBoxLayout(m_popup);
+        layout->setContentsMargins(10, 10, 10, 10);
+        layout->setSpacing(6);
+
+        m_label = new QLabel(QStringLiteral("80%"), m_popup);
        m_label->setAlignment(Qt::AlignCenter);
+        layout->addWidget(m_label);

-        m_slider = new ClickableSlider(Qt::Vertical, widget);
+        m_slider = new ClickableSlider(Qt::Vertical, m_popup);
        m_slider->setRange(0, 100);
        m_slider->setValue(80);
        m_slider->setFixedHeight(120);
+        layout->addWidget(m_slider, 0, Qt::AlignHCenter);

-        layout->addWidget(m_label);
-        layout->addWidget(m_slider);
-
-        auto *action = new QWidgetAction(menu);
-        action->setDefaultWidget(widget);
-        menu->addAction(action);
-        setMenu(menu);
+        // Size the popup at its maximum (label = "100%") and lock it
+        m_label->setText(QStringLiteral("100%"));
+        m_popup->adjustSize();
+        m_popup->setFixedSize(m_popup->sizeHint());
+        m_label->setText(QStringLiteral("80%"));

+        connect(this, &QToolButton::clicked, this, &VolumeButton::togglePopup);
        connect(m_slider, &QSlider::valueChanged, this, [this](int v) {
-            m_label->setText(QString::number(v) + "%");
+            m_label->setText(QString::number(v) + QStringLiteral("%"));
            updateIcon(v);
            emit volumeChanged(v);
        });
@@ -56,14 +58,31 @@ public:
        m_slider->blockSignals(true);
        m_slider->setValue(v);
        m_slider->blockSignals(false);
-        m_label->setText(QString::number(v) + "%");
+        m_label->setText(QString::number(v) + QStringLiteral("%"));
        updateIcon(v);
    }

 signals:
    void volumeChanged(int volume);

+private slots:
+    void togglePopup()
+    {
+        if (m_popup->isVisible()) {
+            m_popup->hide();
+            return;
+        }
+        // Centre popup horizontally over button, place below it
+        const QPoint global = mapToGlobal(
+            QPoint(width() / 2 - m_popup->width() / 2,
+                   height() + 4));
+        m_popup->move(global);
+        m_popup->show();
+        m_popup->raise();
+    }
+
 private:
+    QFrame          *m_popup  = nullptr;
    ClickableSlider *m_slider = nullptr;
    QLabel          *m_label  = nullptr;
Author	SHA1	Message	Date
joren	28771e12d5	fix: lazy-load genre/playlist views and cap playlist search scrolling Some checks failed Build for Windows / build-windows (push) Has been cancelled Details - Defer eager-load scrollbar checks to next event loop iteration via QTimer::singleShot(0), fixing initial load not filling the viewport - Playlist search: eagerly fill viewport, then show "Load more playlists…" button instead of infinite scroll to avoid loading thousands of results - Increase search page size from 8 to 25 - Featured/discover playlists keep auto-scroll behavior unchanged Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-31 11:17:23 +02:00
joren	e9a9077ece	Merge branch 'refactor/code-quality' Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-31 10:54:49 +02:00
joren	86b5673e8a	refactor: reduce duplication and replace magic stack indices - Extract parseTrackItem() static helper in TrackListModel to eliminate ~45 lines of duplicated JSON parsing between setTracks() and appendTracks() - Extract notifyFavChanged() helper to deduplicate addFavId/removeFavId loops - Add StackPage enum to MainContent replacing magic integers 0-5 with named constants (PageWelcome, PageTracks, PageAlbumList, etc.) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-31 10:48:21 +02:00
joren	e453f8acf3	feat: add seamless lazy loading for genre and playlist views Some checks failed Build for Windows / build-windows (push) Has been cancelled Details Introduce paged loading with early prefetch for genre albums/playlists and playlist tracks, while preserving full-data behavior for deep shuffle and playlist play-all actions.	2026-03-31 10:43:36 +02:00
joren	4ebd5ed3f0	fix: detect followed playlists correctly in header Some checks failed Build for Windows / build-windows (push) Has been cancelled Details Load owner+subscriber playlists, track all playlist IDs for follow-state resolution, and keep audio ring buffer at 32k as requested.	2026-03-31 02:02:31 +02:00
joren	1ad3ba4e69	feat: add album favorites in header and unify browse controls Some checks failed Build for Windows / build-windows (push) Has been cancelled Details Improve album workflow with in-header favorite toggle, keep favorite state synced from backend, and normalize browse top-bar sizing while increasing audio output buffer headroom to reduce glitches.	2026-03-31 01:49:53 +02:00
joren	cdac82dbef	fix: sync dock toggles and make autoplay toolbar-only Some checks failed Build for Windows / build-windows (push) Has been cancelled Details	2026-03-31 01:14:43 +02:00
joren	2aff8fda47	fix: stabilize seek slider and clean backend lint issues Some checks failed Build for Windows / build-windows (push) Has been cancelled Details	2026-03-31 00:57:09 +02:00
joren	5673d6cd30	feat: add deep shuffle in genre browse and tighten toolbar layout Some checks failed Build for Windows / build-windows (push) Has been cancelled Details	2026-03-31 00:37:00 +02:00
joren	96bb21adff	feat: add playlist browse/search discovery and follow controls Some checks failed Build for Windows / build-windows (push) Has been cancelled Details	2026-03-31 00:23:56 +02:00
joren	07d6c8a88d	perf: reduce queue and autoplay memory footprint Some checks failed Build for Windows / build-windows (push) Has been cancelled Details	2026-03-30 23:24:30 +02:00
joren	cfd91f96b5	feat: add autoplay suggestions when queue runs out Some checks failed Build for Windows / build-windows (push) Has been cancelled Details	2026-03-30 23:14:43 +02:00
joren	2da934f3f6	feat: restore most-popular search and top results badges Some checks failed Build for Windows / build-windows (push) Has been cancelled Details	2026-03-30 22:53:41 +02:00
joren	3346b424b3	refactor: resync with qbqt baseline and restore genre browser Some checks failed Build for Windows / build-windows (push) Has been cancelled Details	2026-03-30 22:36:39 +02:00
joren	200ef39d04	feat: most-popular search as default Top Results tab Add /most-popular/get endpoint support (discovered via Burp): - Returns mixed artists/albums/tracks ordered by popularity for a query - New 'Top Results' tab shown first/default in the search panel - Badge column: A (artist, blue), H (hi-res album, gold), A (album, gray), T (track, green) - Full context menu support on all item types in the new tab - Both most-popular and regular search fire on submit in parallel Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-30 20:28:13 +02:00
joren	70810bd4b1	feat: qbz-1 streaming, gapless prefetch, accurate scrobbling, Range-seek Port proven playback architecture from qbqt fork: - Bounded VecDeque buffer with condvar backpressure (4MB cap) - decrypt_and_extract_frames for clean FLAC frame extraction from ISOBMFF - Cancel+restart seeking with sub-segment sample skipping - start_prefetch / QueueNext for gapless transitions with pre-started downloads - track_transitioned signaling for scrobbler during gapless playback - Range-request HTTP seeking for non-segmented (MP3) tracks - OnceLock HTTP client singleton with cancel-aware chunked downloads - Accumulated listening time scrobbling (prevents false scrobbles from seeking) - Array-format Last.fm scrobble params (artist[0], track[0], etc.) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-30 20:12:23 +02:00
joren	6c8d032ce9	feat: context menus on search panel, track info dialog, separate shuffle buttons - Add right-click context menus to search panel tracks (play, queue, favorites, playlist, go to album/artist, track info) and albums (open, favorite, go to artist) - Add "Track info..." dialog showing metadata (title, performer, composer, album, quality, hi-res status) — available everywhere: playlists, albums, favorites, search results - Split artist page shuffle into "Shuffle" (popular tracks) and "Shuffle All" (deep shuffle across all releases) - Remove magnifying glass emoji from welcome text Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-25 23:57:42 +01:00
joren	a21d0c8a33	refactor: UI polish — lock sidebar, remove nav buttons, uniform artist tables, deep shuffle - Lock sidebar width (setFixedWidth) so it doesn't jump between views - Remove back/forward navigation buttons and all NavPage history code - Uniform column layout on artist page: hide Artist column from both Popular Tracks and release sections, set matching fixed column widths so columns align vertically across all sections - Deep shuffle: new Rust FFI endpoint fetches tracks from all albums in parallel, combines them, and returns via EV_DEEP_SHUFFLE_OK - Auto-paginate artist releases in Rust (loop until has_more=false) so all releases load at once sorted newest-first Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-25 23:42:00 +01:00
joren	333a620be2	fix: section alignment, pagination, fav state, playback error handling Section toggles left-aligned - Replace QToolButton with flat QPushButton for all section headers; QPushButton properly respects text-align: left in stylesheets Pagination via "Load More" button - QTreeWidget expands to fit all items so the scrollbar-based infinite scroll never triggered; replaced with an explicit "Load more…" button that appears when has_more is true and emits loadMoreRequested Favourite button reflects actual state - MainWindow preloads fav artist IDs on session restore (getFavArtists) and caches them in m_favArtistIds - ArtistView receives the full set via setFavArtistIds() and checks it on every setArtist() call so the button starts gold if already faved - Toggling updates the local cache immediately for back/forward nav Playback error → queue advances - player_loop now sets track_finished on Err (was only set on Ok(None)), so the toolbar's onTrackFinished handler advances to the next track instead of stalling on an unplayable track Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-25 23:22:30 +01:00
joren	b3cc2e3def	chore: gitignore build-viz/, remove accidentally committed build artifacts	2026-03-25 18:25:39 +01:00
joren	3e96b6d7a8	feat: pagination, back/forward nav, context menu, artist fav, image fix Artist portrait - Fix CDN URL: images.portrait.{hash,format} → https://static.qobuz.com/images/artists/covers/large/{hash}.{format} Section alignment - Qt::ToolButtonTextOnly on all section toggles so text is truly left-aligned Auth 401 race condition - qobuz_backend_set_token now uses blocking_lock() instead of spawning an async task, guaranteeing the token is set before any subsequent API call Pagination (infinite scroll) - Release sections load 50 at a time (was 500) - ArtistSection tracks has_more + loaded count; scrolling to the bottom emits loadMoreRequested → ArtistView calls getArtistReleases(offset=N) - AlbumListView gains addAlbums() for append; setReleases routes to setAlbums (offset=0) or appendAlbums (offset>0) Back/Forward navigation - MainToolBar exposes Back/Forward QActions (go-previous/go-next icons) - MainWindow keeps a NavPage vector + index; pushNav() on every album/artist navigation; goBack/goForward re-navigate without pushing history Context menu on now-playing label - Right-click on track label in toolbar → "Go to Album" / "Go to Artist" - MainToolBar stores current track; emits albumRequested/artistRequested signals wired to MainWindow's existing handlers Artist favourites button - ♡ Favourite / ♥ Favourited toggle in artist header - Calls new addFavArtist / removeFavArtist (Rust + Qt backend wiring) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-25 18:25:12 +01:00
joren	963c9ad232	refactor: uniform artist page layout — header + collapsible sections - Artist header now mirrors TrackContextHeader: 120×120 portrait with rounded rect background, large bold name, compact scrollable bio, Play/Shuffle buttons in the same row (gold #FFB232 style) - Play/Shuffle moved out of Popular Tracks into the header area - Popular Tracks becomes a collapsible toggle section identical in appearance to Albums/EPs/Live/Compilations/Other - All section headers share kToggleStyle: left-aligned bold text, ▼/▶ arrow, subtle bottom border, hover highlight - Portrait loading tries hash-based CDN URL first, falls back to image.large / image.small direct URL fields Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-25 18:03:47 +01:00
joren	8310eceeb2	feat: artist portrait, race condition fix, and uniform button styling - Load artist portrait from images.portrait.hash via QNetworkAccessManager - Fix race condition: fire getArtistReleases after setArtist() clears sections, not before (from onArtistLoaded instead of onSearchArtistSelected) - Apply uniform gold (#FFB232) play/shuffle button style matching album view - Make biography scrollable (QTextEdit with max height + scroll on overflow) - Extend track artist name parsing to handle top_tracks {display:...} format Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-25 14:17:36 +01:00
joren	fb58c0ac8c	fix: artist page top tracks and scrollable biography - top_tracks is a flat array in the API response, not {items:[...]} - Replace bio QLabel with scrollable QTextEdit (max 110px, scrolls if longer) - Track model: handle artist.name as {display:...} object for top_tracks format Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-25 14:02:26 +01:00
joren	e37de6d897	fix: correct top_tracks field name and remove unused extra param Qobuz API uses snake_case so the field is top_tracks, not topTracks. Also remove the extra=topTracks query param — top tracks are included in the default artist/page response without it. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-25 13:58:51 +01:00
joren	5ae18afa08	feat: full artist release list via artist/getReleasesList Instead of relying on the limited preview in artist/page, fire a separate artist/getReleasesList request per release type (album, epSingle, live, compilation) in parallel when loading an artist. Each result updates its section independently as it arrives, so the page populates progressively without a single large request. Also fixes the artist name in the status bar (was reading wrong field). Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-25 13:53:57 +01:00
joren	6f11b364aa	feat: show top tracks on artist profile with play/shuffle - Adds extra=topTracks to artist/page API request - Embeds a List::Tracks widget at the top of ArtistView showing the artist's most popular tracks, with Play and Shuffle buttons - Bubbles playTrackRequested through MainContent up to MainWindow - Also adds the viz PCM ring buffer FFI infrastructure (for future spectrum widget) to the Rust backend Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-25 13:45:19 +01:00
joren	4ba6d00748	fix: artistview nullptr connect warning + album version in header - Move updateToggleText() after m_list creation to avoid null connects - Show version (e.g. "Deluxe") in album header title Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-24 23:55:12 +01:00
joren	e4c2694584	chore: remove dead code to eliminate all compiler warnings - Remove unused get_artist() (replaced by get_artist_page()) - Remove unused Format::label(), Format::all() - Remove unused QwsTokenResponse and QwsToken structs - Remove unused PlayerCommand::Seek (seeking uses atomics directly) - Remove unused PlayerState::Stopped, TrackInfo::format - Remove unused PlayerStatus::get_current_track() Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-24 23:27:51 +01:00
joren	5d0011cb90	Merge fix/code-quality-audit into main	2026-03-24 23:19:09 +01:00
joren	5bda2396d1	fix: security hardening and code quality improvements Build hardening: - Add -fstack-protector-strong, -D_FORTIFY_SOURCE=2, PIE, full RELRO - Enable overflow-checks in Rust release profile Rust backend: - Return null (not panic) if Tokio runtime or QobuzClient init fails - Strip null bytes in FFI JSON callback to prevent CString panics - Document MD5 and password-in-query as Qobuz API constraints C++ frontend: - Validate JSON document before accessing fields in onEvent() - Handle null backend pointer from failed init - Set biography label to PlainText and decode HTML entities to prevent rendering injected content from API responses - Clamp slider position and guard negative durations - Use qint64 for duration formatting to avoid int truncation Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-24 23:19:04 +01:00
joren	eb5c151d3a	Merge feat/multi-disc-artist-sections into main	2026-03-24 23:09:11 +01:00
joren	872fdecdce	feat: artist/page endpoint, multi-disc fix, playlist ownership, UX improvements - Switch artist view to artist/page API (proper sections: Albums, Singles & EPs, Live, Compilations; version in titles like "Deluxe") - Fix artist sections categorization using releases[].type from artist/page - Add getUser() backend call; fetch on session restore when userId=0 to fix playlist ownership (Remove from playlist / Delete playlist were missing) - Fix multi-disc double-click / Play Now queue start index (disc headers were counted in row index but excluded from currentTracksJson) - Hide redundant Album column when viewing an album - Make artist name in context header clickable (navigates to artist page) - Fix gap between title and artist name in context header (addStretch) - Fix queue panel track titles to include version field - Fix album list to show version in title column Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-24 23:09:04 +01:00
joren	69fb818c38	Merge feat/playlist-gapless-theme into main Features and fixes from this branch: - Album/playlist context header with art, metadata, Play & Shuffle buttons - Playlist ownership filtering (delete, remove-from-playlist, add-to-playlist) - Gapless toggle that actually works (controls audio output lifecycle) - Resolution display in album header (e.g. 24-bit / 96 kHz) - Now-playing art scales to dock width via ArtWidget (hasHeightForWidth) - Skip unavailable tracks in queue; non-streamable tracks filtered out - Artist profile: collapsible Albums / EPs & Singles / Other sections - Favorites star indicator + context menu shows Add or Remove only - Shuffle button does one-time shuffle without setting global flag - Volume popup replaced with Qt::Popup QFrame (no lag, correct alignment) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-24 17:56:54 +01:00
joren	56473cae6f	feat: artist sections, fav indicator, art scaling fix, volume popup fix - Artist profile: collapsible Albums / EPs & Singles / Other sections keyed on release_type; fetches up to 200 albums per artist - Favorites: starred icon on favorited tracks, context menu shows Add or Remove (not both); IDs cached when fav tracks are loaded - Shuffle button: one-time shuffle via shuffleNow() without touching global shuffle flag, so double-click still plays in order - Now-playing art: replaced setFixedHeight hack with ArtWidget that overrides hasHeightForWidth() — scales smoothly up and down, no min-size - Volume popup: replaced QMenu (laggy, broken drag) with Qt::Popup QFrame; appears below button; fixed size locked at 100% label width Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-24 17:56:47 +01:00