iOS 1.0.8: stem playlists, karaoke softness slider in lyrics

- Playlists tab splits into Plex and Stem. Plex playlists are unchanged and
  now show their custom poster when one is set.
- Stem playlists live on the device; each song keeps its own mix. Add from
  any song or collection menu, or copy a whole Plex playlist.
- Queue items can carry a mix, which wins over the song's saved mix.
- Softness slider under the Vocals picker in lyrics when set to Soft.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

ios/Stemify/App/AppGraph.swift

@@ -20,6 +20,7 @@ final class AppGraph {
     let cache: MediaCache
     let eq: EqController
     let playback: PlaybackManager
+    let stemPlaylists: StemPlaylists
     let downloads: Downloads
     let coverage: StemCoverage
     let nowPlaying: NowPlaying
@@ -59,6 +60,7 @@ final class AppGraph {
         cache = MediaCache(dir: media, session: mediaSession) { Int64(settings.cacheLimitGb) << 30 }
 
         eq = EqController(dir: support)
+        stemPlaylists = StemPlaylists(dir: support)
         playback = PlaybackManager(settings: settings, plex: plex, stems: stems, cache: cache, eq: eq, dir: support)
         downloads = Downloads(settings: settings, plex: plex, stems: stems, cache: cache, net: net, dir: support)
         coverage = StemCoverage(plex: plex, stems: stems, settings: settings, dir: support)

ios/Stemify/Core/Settings.swift

@@ -186,6 +186,8 @@ final class Settings: @unchecked Sendable {
     /// Downloads page order: 0 download order, 1 artist, 2 release date.
     var downloadSort: Int { get { read(\.downloadSort, "downloadSort", 0) } set { write(\.downloadSort, "downloadSort", newValue, 0) } }
     var karaokeVocals: Int { get { read(\.karaokeVocals, "karaokeVocals", KaraokeVocals.Off.rawValue) } set { write(\.karaokeVocals, "karaokeVocals", newValue, KaraokeVocals.Off.rawValue) } }
+    /// How far down Soft karaoke puts the vocals, in dB.
+    var karaokeSoftDb: Int { get { read(\.karaokeSoftDb, "karaokeSoftDb", -12) } set { write(\.karaokeSoftDb, "karaokeSoftDb", newValue, -12) } }
     var keepStemMix: Bool { get { read(\.keepStemMix, "keepStemMix", true) } set { write(\.keepStemMix, "keepStemMix", newValue, true) } }
     var masterVolume: Float {
         get { access(keyPath: \.masterVolume); lock.lock(); defer { lock.unlock() }; return (store["masterVolume"] as? NSNumber)?.floatValue ?? 0.85 }

ios/Stemify/Playback/PlaybackManager.swift

@@ -46,6 +46,8 @@ enum SourceKind { case None, Stems, Original }
 struct QueueItem: Codable, Hashable, Identifiable {
     var uid: Int64
     var track: Track
+    /// Set when the song came from a stem playlist; it plays with this mix instead of its saved one.
+    var mix: [String: StemSetting]?
     var id: Int64 { uid }
 }
 
@@ -204,16 +206,17 @@ final class PlaybackManager: StemEngineListener, @unchecked Sendable {
 
     // ---- queue --------------------------------------------------------------------------
 
-    private func items(_ tracks: [Track]) -> [QueueItem] {
+    private func items(_ tracks: [Track], _ mixes: [[String: StemSetting]]? = nil) -> [QueueItem] {
-        tracks.map { t in
+        tracks.enumerated().map { i, t in
             defer { nextUid += 1 }
-            return QueueItem(uid: nextUid, track: t)
+            return QueueItem(uid: nextUid, track: t, mix: mixes.flatMap { i < $0.count ? $0[i] : nil })
         }
     }
 
-    func playTracks(_ tracks: [Track], start: Int = 0, shuffle doShuffle: Bool = false) {
+    /// `mixes` lines up with `tracks`: each song plays with its own mix (stem playlists).
+    func playTracks(_ tracks: [Track], mixes: [[String: StemSetting]]? = nil, start: Int = 0, shuffle doShuffle: Bool = false) {
         if tracks.isEmpty { return }
-        let items = items(tracks)
+        let items = items(tracks, mixes)
         if doShuffle {
             unshuffled = items
             let first = start > 0 && start < items.count ? items[start] : items.randomElement()!
@@ -228,12 +231,12 @@ final class PlaybackManager: StemEngineListener, @unchecked Sendable {
         }
     }
 
-    func playNext(_ tracks: [Track]) { insert(index + 1, tracks) }
+    func playNext(_ tracks: [Track], mixes: [[String: StemSetting]]? = nil) { insert(index + 1, tracks, mixes) }
-    func addToQueue(_ tracks: [Track]) { insert(queue.count, tracks) }
+    func addToQueue(_ tracks: [Track], mixes: [[String: StemSetting]]? = nil) { insert(queue.count, tracks, mixes) }
 
-    private func insert(_ at: Int, _ tracks: [Track]) {
+    private func insert(_ at: Int, _ tracks: [Track], _ mixes: [[String: StemSetting]]? = nil) {
         if tracks.isEmpty { return }
-        let items = items(tracks)
+        let items = items(tracks, mixes)
         var q = queue
         q.insert(contentsOf: items, at: min(max(at, 0), q.count))
         queue = q
@@ -415,17 +418,18 @@ final class PlaybackManager: StemEngineListener, @unchecked Sendable {
         pushMix()
     }
 
-    /// The mix a song starts with: karaoke if that's on, else the song's saved mix, else cleared (or kept, per settings).
+    /// The mix a song starts with: karaoke if that's on, else its stem playlist mix, else the song's saved mix,
-    private func startMix(_ t: Track) -> [String: StemSetting] {
+    /// else cleared (or kept, per settings).
+    private func startMix(_ item: QueueItem) -> [String: StemSetting] {
         if karaoke { return karaokeMix }
-        return songMixes[t.ratingKey] ?? (settings.keepStemMix ? mix : [:])
+        return item.mix ?? songMixes[item.track.ratingKey] ?? (settings.keepStemMix ? mix : [:])
     }
 
-    /// How much of the singer is left in karaoke mode. Soft is about -12 dB, a guide under your own voice.
+    /// How much of the singer is left in karaoke mode. Soft is a guide under your own voice, as quiet as settings say.
     private var karaokeMix: [String: StemSetting] {
         switch karaokeVocals {
         case .On: return [:]
-        case .Soft: return ["vocals": StemSetting(level: 0.4)]
+        case .Soft: return ["vocals": StemSetting(level: stemUntaper(Float(pow(10, Double(settings.karaokeSoftDb) / 20))))]
         case .Off: return ["vocals": StemSetting(muted: true)]
         }
     }
@@ -437,6 +441,11 @@ final class PlaybackManager: StemEngineListener, @unchecked Sendable {
         if karaoke { applyMix(karaokeMix) }
     }
 
+    func setKaraokeSoftDb(_ db: Int) {
+        settings.karaokeSoftDb = db
+        if karaoke && karaokeVocals == .Soft { applyMix(karaokeMix) }
+    }
+
     /// Turning it off puts back the song's saved mix, or the one from before, unless the mix was changed meanwhile.
     func setKaraoke(_ on: Bool) {
         guard on != karaoke else { return }
@@ -522,7 +531,7 @@ final class PlaybackManager: StemEngineListener, @unchecked Sendable {
         if play && !activateSession() { return }
         playWhenReady = play
         buffering = true
-        mix = startMix(item.track)
+        mix = startMix(item)
         changed()
         save()
         loadTask = Task { @MainActor [weak self] in
@@ -695,7 +704,7 @@ final class PlaybackManager: StemEngineListener, @unchecked Sendable {
         guard let item = current else { return }
         durationMs = item.track.durationMs
         waveform = nil
-        mix = startMix(item.track)
+        mix = startMix(item)
         source = currentEntry != nil ? .Stems : .Original
         stemNames = Stems.sort(currentEntry?.stems.map(\.name) ?? ["mix"])
         pushMix()

ios/Stemify/Playback/StemPlaylists.swift

@@ -0,0 +1,86 @@
+import Foundation
+import Observation
+
+/// One song in a stem playlist, saved with the mix it plays with.
+struct StemPlaylistItem: Codable, Hashable, Identifiable {
+    var uid = UUID().uuidString
+    var track: Track
+    var mix: [String: StemSetting]
+    var id: String { uid }
+}
+
+struct StemPlaylist: Codable, Hashable, Identifiable {
+    var id = UUID().uuidString
+    var title: String
+    var items: [StemPlaylistItem] = []
+    var created = Date()
+    var updated = Date()
+
+    var tracks: [Track] { items.map(\.track) }
+    var mixes: [[String: StemSetting]] { items.map(\.mix) }
+    var thumb: String? { items.lazy.compactMap(\.track.thumb).first }
+    var durationMs: Int64 { items.reduce(0) { $0 + $1.track.durationMs } }
+}
+
+/// Playlists that live on this device only: each song keeps its own stem mix (instrumentals, a cappellas…).
+/// Plex playlists can't hold a mix, so these are separate.
+@MainActor @Observable
+final class StemPlaylists {
+    private(set) var lists: [StemPlaylist] = []
+    @ObservationIgnored private let file: URL
+
+    /// Every stem a song can have, for naming saved mixes without loading the song.
+    static let allStems = ["vocals", "drums", "bass", "guitar", "piano", "other"]
+
+    init(dir: URL) {
+        file = dir.appendingPathComponent("stem-playlists.json")
+        lists = (try? JSONDecoder().decode([StemPlaylist].self, from: Data(contentsOf: file))) ?? []
+    }
+
+    func list(_ id: String) -> StemPlaylist? { lists.first { $0.id == id } }
+
+    @discardableResult
+    func create(_ title: String, tracks: [Track] = [], mix: [String: StemSetting] = [:]) -> StemPlaylist {
+        let pl = StemPlaylist(title: title, items: tracks.map { StemPlaylistItem(track: $0, mix: MixPresets.normalized(mix)) })
+        lists.insert(pl, at: 0)
+        save()
+        return pl
+    }
+
+    func add(_ id: String, tracks: [Track], mix: [String: StemSetting]) {
+        edit(id) { $0.items += tracks.map { StemPlaylistItem(track: $0, mix: MixPresets.normalized(mix)) } }
+    }
+
+    func setItems(_ id: String, _ items: [StemPlaylistItem]) { edit(id) { $0.items = items } }
+    func remove(_ id: String, item: String) { edit(id) { $0.items.removeAll { $0.uid == item } } }
+    func setMix(_ id: String, item: String, _ mix: [String: StemSetting]) {
+        edit(id) { pl in if let i = pl.items.firstIndex(where: { $0.uid == item }) { pl.items[i].mix = MixPresets.normalized(mix) } }
+    }
+    func rename(_ id: String, _ title: String) { edit(id) { $0.title = title } }
+
+    func delete(_ id: String) {
+        lists.removeAll { $0.id == id }
+        save()
+    }
+
+    /// "Instrumental", "A Cappella"… or "Custom Mix" for a hand-made one.
+    static func label(_ mix: [String: StemSetting]) -> String {
+        if MixPresets.normalized(mix).isEmpty { return MixPresets.full.label }
+        if MixPresets.current(allStems, mix) == MixPresets.karaoke { return "Instrumental" }
+        return MixPresets.current(allStems, mix)?.label ?? "Custom Mix"
+    }
+
+    private func edit(_ id: String, _ change: (inout StemPlaylist) -> Void) {
+        guard let i = lists.firstIndex(where: { $0.id == id }) else { return }
+        change(&lists[i])
+        lists[i].updated = Date()
+        save()
+    }
+
+    private func save() {
+        let all = lists, file = file
+        DispatchQueue.global(qos: .utility).async {
+            if let data = try? JSONEncoder().encode(all) { try? data.write(to: file, options: .atomic) }
+        }
+    }
+}

ios/Stemify/Plex/PlexModels.swift

@@ -405,7 +405,7 @@ extension PlexItem {
     func toArtist() -> Artist { Artist(ratingKey: ratingKey, title: title, sortTitle: titleSort ?? title, thumb: thumb) }
 
     func toPlaylist() -> Playlist {
-        Playlist(ratingKey: ratingKey, title: title, thumb: composite ?? thumb, trackCount: leafCount ?? 0,
+        Playlist(ratingKey: ratingKey, title: title, thumb: thumb ?? composite, trackCount: leafCount ?? 0,
                  durationMs: duration ?? 0, smart: smart ?? false)
     }
 }

ios/Stemify/UI/Components/MediaMenu.swift

@@ -17,6 +17,7 @@ struct MediaMenu {
             a.append(SheetAction("Remove Download", icon: "trash", destructive: true) { g.downloads.remove([t]) })
         }
         a.append(SheetAction("Add to Playlist…", icon: "text.badge.plus") { addToPlaylist([t]) })
+        a.append(SheetAction("Add to Stem Playlist…", icon: "slider.horizontal.3") { addToStemPlaylist([t]) })
         if t.partFile != nil, g.stems.index.size > 0, g.stems.find(t) == nil { a.append(stemNow { [t] }) }
         if allowGoTo, let k = t.albumKey {
             a.append(SheetAction("Go to Album", icon: "square.stack") {
@@ -52,10 +53,49 @@ struct MediaMenu {
 
     func playlist(_ pl: Playlist, extra: [SheetAction] = []) -> [SheetAction] {
         let plex = g.plex
-        return collection(pl.title, [], false, { try await plex.playlistTracks(pl.ratingKey) }, playlistKey: pl.ratingKey, extra: extra,
+        let copy = SheetAction("Copy to Stem Playlist…", icon: "doc.on.doc") { copyToStems(pl) }
+        return collection(pl.title, [], false, { try await plex.playlistTracks(pl.ratingKey) }, playlistKey: pl.ratingKey, extra: [copy] + extra,
                           confirmDownload: pl.trackCount > 50)
     }
 
+    func stemPlaylist(_ pl: StemPlaylist, extra: [SheetAction] = [], onPage: Bool = false) -> [SheetAction] {
+        var a = [
+            SheetAction("Add to Front of Queue", icon: "text.line.first.and.arrowtriangle.forward") {
+                g.playback.playNext(pl.tracks, mixes: pl.mixes); overlays.hud("Playing Next", "text.line.first.and.arrowtriangle.forward")
+            },
+            SheetAction("Add to End of Queue", icon: "text.line.last.and.arrowtriangle.forward") {
+                g.playback.addToQueue(pl.tracks, mixes: pl.mixes); overlays.hud("Added to Queue", "text.line.last.and.arrowtriangle.forward")
+            },
+        ]
+        let missing = pl.tracks.filter { !g.downloads.isDownloaded($0.ratingKey) }
+        if !missing.isEmpty {
+            a.append(SheetAction("Download", icon: "arrow.down.circle") { g.downloads.download(missing); overlays.hud("Downloading", "arrow.down.circle") })
+        }
+        if pl.items.isEmpty { a = [] }
+        let lists = g.stemPlaylists
+        a.append(SheetAction("Delete Stem Playlist", icon: "trash", destructive: true) {
+            overlays.confirm("Delete “\(pl.title)”?", "Stem playlists are only on this device.", "Delete") { lists.delete(pl.id); if onPage { ui.pop() } }
+        })
+        return extra + a
+    }
+
+    /// A song in a stem playlist: queue it with its mix, change the mix, or take it out.
+    func stemItem(_ item: StemPlaylistItem, in listId: String) -> [SheetAction] {
+        let lists = g.stemPlaylists
+        return [
+            SheetAction("Add to Front of Queue", icon: "text.line.first.and.arrowtriangle.forward") {
+                g.playback.playNext([item.track], mixes: [item.mix]); overlays.hud("Playing Next", "text.line.first.and.arrowtriangle.forward")
+            },
+            SheetAction("Add to End of Queue", icon: "text.line.last.and.arrowtriangle.forward") {
+                g.playback.addToQueue([item.track], mixes: [item.mix]); overlays.hud("Added to Queue", "text.line.last.and.arrowtriangle.forward")
+            },
+            SheetAction("Change Mix…", icon: "slider.horizontal.3") {
+                chooseMix([item.track]) { lists.setMix(listId, item: item.uid, $0) }
+            },
+            SheetAction("Remove from Stem Playlist", icon: "minus.circle", destructive: true) { lists.remove(listId, item: item.uid) },
+        ]
+    }
+
     /// For songs already in hand (downloads with no Plex album behind them).
     func tracks(_ title: String, _ tracks: [Track], extra: [SheetAction] = []) -> [SheetAction] {
         let have = tracks.filter { g.downloads.isDownloaded($0.ratingKey) }
@@ -90,6 +130,7 @@ struct MediaMenu {
             })
         }
         a.append(SheetAction("Add to Playlist…", icon: "text.badge.plus") { withTracks(load) { addToPlaylist($0, skip: playlistKey) } })
+        a.append(SheetAction("Add to Stem Playlist…", icon: "slider.horizontal.3") { withTracks(load) { addToStemPlaylist($0) } })
         if !stemmed { a.append(stemNow(load)) }
         return a + extra
     }
@@ -160,6 +201,66 @@ struct MediaMenu {
         }
     }
 
+    /// Picks the mix the songs get in a stem playlist: what's playing now, the song's saved mix, or a preset.
+    func chooseMix(_ tracks: [Track], _ then: @escaping ([String: StemSetting]) -> Void) {
+        let pm = g.playback
+        var acts: [SheetAction] = []
+        if tracks.count == 1, let t = tracks.first {
+            if pm.current?.track.ratingKey == t.ratingKey {
+                let m = pm.mix
+                acts.append(SheetAction("Current Mix (\(StemPlaylists.label(m)))", icon: "play.circle") { then(m) })
+            }
+            if let m = pm.songMixes[t.ratingKey] {
+                acts.append(SheetAction("This Song’s Mix (\(StemPlaylists.label(m)))", icon: "bookmark") { then(m) })
+            }
+        }
+        for p in MixPresets.all {
+            guard let m = p.build(StemPlaylists.allStems) else { continue }
+            acts.append(SheetAction(StemPlaylists.label(m)) { then(m) })
+        }
+        overlays.actions("Choose a Mix", acts)
+    }
+
+    func addToStemPlaylist(_ tracks: [Track]) {
+        let lists = g.stemPlaylists
+        overlays.actions("Add \(songs(tracks.count)) to Stem Playlist", [SheetAction("New Stem Playlist…") { newStemPlaylist(tracks) }] + lists.lists.map { pl in
+            SheetAction(pl.title) {
+                chooseMix(tracks) { m in
+                    lists.add(pl.id, tracks: tracks, mix: m)
+                    overlays.hud("Added to \(pl.title)")
+                }
+            }
+        })
+    }
+
+    func newStemPlaylist(_ tracks: [Track] = [], onCreated: @escaping (StemPlaylist) -> Void = { _ in }) {
+        let lists = g.stemPlaylists
+        overlays.prompt("New Stem Playlist", "Every song in it plays with the mix you pick.", "Create", placeholder: "Playlist name") { name in
+            if tracks.isEmpty {
+                onCreated(lists.create(name))
+                return
+            }
+            chooseMix(tracks) { m in
+                onCreated(lists.create(name, tracks: tracks, mix: m))
+                overlays.hud("Created “\(name)”")
+            }
+        }
+    }
+
+    /// Makes a stem playlist from a Plex one, every song with the same mix.
+    func copyToStems(_ pl: Playlist, onCreated: @escaping (StemPlaylist) -> Void = { _ in }) {
+        let plex = g.plex
+        let lists = g.stemPlaylists
+        overlays.prompt("Copy to Stem Playlist", "Every song gets the mix you pick next; change single songs later.", initial: pl.title, "Next") { name in
+            withTracks({ try await plex.playlistTracks(pl.ratingKey) }) { tracks in
+                chooseMix(tracks) { m in
+                    onCreated(lists.create(name, tracks: tracks, mix: m))
+                    overlays.hud("Copied \(songs(tracks.count))")
+                }
+            }
+        }
+    }
+
     func newPlaylist(_ tracks: [Track], onCreated: @escaping () -> Void = {}) {
         let plex = g.plex
         overlays.prompt("New Playlist", "Name it; you can add more songs later.", "Create", placeholder: "Playlist name") { name in

ios/Stemify/UI/Nav.swift

@@ -18,7 +18,7 @@ enum Route: Hashable {
     case Artists, Albums, Songs, Playlists
     case Eq, EqFilters(profileId: String), EqFilterPage(profileId: String, filterId: String)
     case PlexAccount, StemServer, Quality, Storage, Appearance
-    case ArtistPage(Artist), AlbumPage(Album), PlaylistPage(Playlist)
+    case ArtistPage(Artist), AlbumPage(Album), PlaylistPage(Playlist), StemPlaylistPage(String)
 }
 
 /// Tabs, their stacks and the Now Playing sheet: the things any screen can ask of the shell.

ios/Stemify/UI/RootView.swift

@@ -14,15 +14,12 @@ struct RootView: View {
                     root(t).miniPlayerRoom()
                         .navigationDestination(for: Route.self) { destination($0).miniPlayerRoom() }
                 }
-                // Floats over the screens; each screen leaves room for it so nothing ends up underneath.
+                .modifier(FloatingMiniPlayer())
-                .overlay(alignment: .bottom) {
-                    if g.playback.current != nil { MiniPlayer().transition(.move(edge: .bottom).combined(with: .opacity)) }
-                }
-                .animation(.spring(duration: 0.35), value: g.playback.current != nil)
                 .tabItem { Label(t.rawValue, systemImage: t.icon) }
                 .tag(t)
             }
         }
+        .modifier(GlassMiniPlayerHost())
         .sheet(isPresented: Binding(get: { ui.nowPlayingOpen }, set: { ui.nowPlayingOpen = $0 })) {
             NowPlayingScreen()
                 .overlayHost(ui.overlays, level: 1)
@@ -68,6 +65,39 @@ struct RootView: View {
         case .ArtistPage(let a): ArtistScreen(artist: a)
         case .AlbumPage(let a): AlbumScreen(album: a)
         case .PlaylistPage(let pl): PlaylistScreen(playlist: pl)
+        case .StemPlaylistPage(let id): StemPlaylistScreen(id: id)
+        }
+    }
+}
+
+/// iOS 26.1 and up put the mini player in the tab bar's glass accessory; older ones float a card over each tab.
+private let glassAccessory: Bool = { if #available(iOS 26.1, *) { return true } else { return false } }()
+
+private struct GlassMiniPlayerHost: ViewModifier {
+    private var g: AppGraph { .shared }
+    func body(content: Content) -> some View {
+        if #available(iOS 26.1, *) {
+            content
+                .tabViewBottomAccessory(isEnabled: g.playback.current != nil) { MiniPlayer() }
+                .tabBarMinimizeBehavior(.onScrollDown)
+        } else {
+            content
+        }
+    }
+}
+
+/// Floats over the screens; each screen leaves room for it so nothing ends up underneath.
+private struct FloatingMiniPlayer: ViewModifier {
+    private var g: AppGraph { .shared }
+    func body(content: Content) -> some View {
+        if glassAccessory {
+            content
+        } else {
+            content
+                .overlay(alignment: .bottom) {
+                    if g.playback.current != nil { MiniPlayer().transition(.move(edge: .bottom).combined(with: .opacity)) }
+                }
+                .animation(.spring(duration: 0.35), value: g.playback.current != nil)
         }
     }
 }
@@ -76,7 +106,7 @@ private struct MiniPlayerRoom: ViewModifier {
     private var g: AppGraph { .shared }
     func body(content: Content) -> some View {
         content.safeAreaInset(edge: .bottom, spacing: 0) {
-            if g.playback.current != nil { Color.clear.frame(height: 66) }
+            if !glassAccessory && g.playback.current != nil { Color.clear.frame(height: 66) }
         }
     }
 }

ios/Stemify/UI/Screens/NowPlayingScreen.swift

@@ -794,8 +794,14 @@ struct MiniPlayer: View {
     private var g: AppGraph { .shared }
 
     var body: some View {
+        if let t = g.playback.current?.track {
+            if #available(iOS 26.1, *) { GlassMiniPlayer(track: t) } else { card(t) }
+        }
+    }
+
+    /// Before iOS 26: a card floating over each tab.
+    @ViewBuilder private func card(_ t: Track) -> some View {
         let pm = g.playback
-        if let t = pm.current?.track {
         HStack(spacing: 0) {
             Artwork(thumb: t.thumb, size: 44, corner: 8).padding(.trailing, 12)
             VStack(alignment: .leading, spacing: 1) {
@@ -803,19 +809,7 @@ struct MiniPlayer: View {
                 Text(t.artist).font(.footnote).foregroundStyle(p.label2).lineLimit(1)
             }
             Spacer(minLength: 6)
-                Button(action: pm.togglePlay) {
+            MiniTransport(color: p.label, next: true)
-                    ZStack {
-                        if pm.buffering && pm.playWhenReady { ProgressView() }
-                        else { Image(systemName: pm.playWhenReady ? "pause.fill" : "play.fill").font(.system(size: 22)).contentTransition(.symbolEffect(.replace)) }
-                    }
-                    .animation(.snappy(duration: 0.25), value: pm.playWhenReady)
-                    .foregroundStyle(p.label).frame(width: 44, height: 44).contentShape(Rectangle())
-                }
-                .buttonStyle(PressFade())
-                Button(action: pm.next) {
-                    Image(systemName: "forward.fill").font(.system(size: 20)).foregroundStyle(p.label).frame(width: 44, height: 44).contentShape(Rectangle())
-                }
-                .buttonStyle(PressFade())
         }
         .padding(.leading, 8).padding(.trailing, 6)
         .frame(height: 60)
@@ -845,6 +839,56 @@ struct MiniPlayer: View {
         .gesture(DragGesture(minimumDistance: 20).onEnded { v in if v.translation.height < -30 { ui.openNowPlaying() } })
         .actionsMenu(ui.menu.track(t))
     }
+}
+
+/// iOS 26: lives in the tab bar's Liquid Glass accessory, like Music. Shrinks to title and play when the bar collapses.
+@available(iOS 26.1, *)
+private struct GlassMiniPlayer: View {
+    let track: Track
+    @Environment(Ui.self) private var ui
+    @Environment(\.tabViewBottomAccessoryPlacement) private var placement
+    private var inline: Bool { placement == .inline }
+
+    var body: some View {
+        HStack(spacing: 10) {
+            Artwork(thumb: track.thumb, size: inline ? 28 : 34, corner: 6)
+            VStack(alignment: .leading, spacing: 0) {
+                Text(track.title).font(.subheadline.weight(.semibold)).lineLimit(1)
+                if !inline { Text(track.artist).font(.caption).foregroundStyle(.secondary).lineLimit(1) }
+            }
+            Spacer(minLength: 4)
+            MiniTransport(color: .primary, next: !inline)
+        }
+        .padding(.leading, 10).padding(.trailing, 6)
+        .contentShape(Rectangle())
+        .onTapGesture { ui.openNowPlaying() }
+        .actionsMenu(ui.menu.track(track))
+    }
+}
+
+/// Play/pause (spinner while buffering) and next, for the mini player.
+private struct MiniTransport: View {
+    let color: Color
+    let next: Bool
+    private var g: AppGraph { .shared }
+
+    var body: some View {
+        let pm = g.playback
+        Button(action: pm.togglePlay) {
+            ZStack {
+                if pm.buffering && pm.playWhenReady { ProgressView() }
+                else { Image(systemName: pm.playWhenReady ? "pause.fill" : "play.fill").font(.system(size: 22)).contentTransition(.symbolEffect(.replace)) }
+            }
+            .animation(.snappy(duration: 0.25), value: pm.playWhenReady)
+            .foregroundStyle(color).frame(width: 44, height: 44).contentShape(Rectangle())
+        }
+        .buttonStyle(PressFade())
+        if next {
+            Button(action: pm.next) {
+                Image(systemName: "forward.fill").font(.system(size: 20)).foregroundStyle(color).frame(width: 44, height: 44).contentShape(Rectangle())
+            }
+            .buttonStyle(PressFade())
+        }
     }
 }
 
@@ -868,6 +912,15 @@ private struct LyricsPanel: View {
                 .pickerStyle(.segmented)
             }
             .padding(.horizontal, 28).padding(.top, 8)
+            if g.playback.karaokeVocals == .Soft {
+                let db = g.settings.karaokeSoftDb
+                HStack(spacing: 12) {
+                    Text("Softness").font(.subheadline.weight(.semibold)).foregroundStyle(p.label2)
+                    Slider(value: Binding(get: { Double(db) }, set: { g.playback.setKaraokeSoftDb(Int($0.rounded())) }), in: -30...(-3), step: 1)
+                    Text("\(db) dB").font(.caption).monospacedDigit().foregroundStyle(p.label2).frame(width: 46, alignment: .trailing)
+                }
+                .padding(.horizontal, 28).padding(.top, 8)
+            }
             content
         }
         .task(id: track.ratingKey) { await follow() }

ios/Stemify/UI/Screens/PlaylistScreens.swift

@@ -2,15 +2,25 @@ import SwiftUI
 
 // ---- playlists ------------------------------------------------------------------------------
 
+enum PlaylistKind: String, CaseIterable { case Plex, Stem }
+
 struct PlaylistsScreen: View {
     @Environment(Ui.self) private var ui
     @State private var lists: LoadState<[Playlist]> = .loading
     @State private var reload = 0
+    @AppStorage("playlistKind") private var kind = PlaylistKind.Plex
     private let sort = SortState("playlists", PLAYLIST_SORTS)
     private var g: AppGraph { .shared }
 
     var body: some View {
         Page(title: "Playlists") {
+            Picker("Kind", selection: $kind) {
+                Text("Plex").tag(PlaylistKind.Plex)
+                Text("Stem").tag(PlaylistKind.Stem)
+            }
+            .pickerStyle(.segmented)
+            .padding(.horizontal, MARGIN).padding(.bottom, 8)
+            if kind == .Plex {
                 Loaded(state: lists, retry: { reload += 1 }) { list in
                     if list.isEmpty {
                         EmptyState(icon: "music.note.list", title: "No Playlists",
@@ -20,11 +30,21 @@ struct PlaylistsScreen: View {
                         PlaylistRow(playlist: pl).onTapGesture { ui.push(.PlaylistPage(pl)) }.actionsMenu(ui.menu.playlist(pl))
                     }
                 }
+            } else {
+                let stems = g.stemPlaylists.lists
+                if stems.isEmpty {
+                    EmptyState(icon: "slider.horizontal.3", title: "No Stem Playlists",
+                               message: "Each song plays with its own mix, like an instrumental or a cappella. Hold any song and choose “Add to Stem Playlist”, or copy a Plex playlist with +.")
+                }
+                ForEach(stems) { pl in
+                    StemPlaylistRow(playlist: pl).onTapGesture { ui.push(.StemPlaylistPage(pl.id)) }.actionsMenu(ui.menu.stemPlaylist(pl))
+                }
+            }
         }
         .toolbar {
-            ToolbarItem(placement: .topBarTrailing) { SortMenu(sort: sort) }
+            if kind == .Plex { ToolbarItem(placement: .topBarTrailing) { SortMenu(sort: sort) } }
             ToolbarItem(placement: .topBarTrailing) {
-                Button { newPlaylist() } label: { Image(systemName: "plus") }
+                Button { kind == .Plex ? newPlaylist() : newStemPlaylist() } label: { Image(systemName: "plus") }
             }
         }
         .task(id: "\(g.settings.musicSection)|\(sort.param)|\(reload)") {
@@ -45,6 +65,130 @@ struct PlaylistsScreen: View {
         if acts.isEmpty { ui.overlays.hud("Play something first, or use “Add to Playlist” on any song.", "info.circle") }
         else { ui.overlays.actions("New Playlist", acts) }
     }
+
+    private func newStemPlaylist() {
+        let menu = ui.menu
+        let open: (StemPlaylist) -> Void = { ui.push(.StemPlaylistPage($0.id)) }
+        ui.overlays.actions("New Stem Playlist", [
+            SheetAction("Empty Stem Playlist…", icon: "plus") { menu.newStemPlaylist(onCreated: open) },
+            SheetAction("Copy from Plex Playlist…", icon: "doc.on.doc") {
+                Task {
+                    guard let plex = try? await g.plex.playlists() else {
+                        ui.overlays.hud("Couldn't load playlists", "exclamationmark.triangle")
+                        return
+                    }
+                    if plex.isEmpty { ui.overlays.hud("No Plex playlists to copy", "info.circle"); return }
+                    ui.overlays.actions("Copy from Plex", plex.map { pl in SheetAction(pl.title) { menu.copyToStems(pl, onCreated: open) } })
+                }
+            },
+        ])
+    }
+}
+
+struct StemPlaylistRow: View {
+    let playlist: StemPlaylist
+    @Environment(\.palette) private var p
+    var body: some View {
+        HStack(spacing: 14) {
+            Artwork(thumb: playlist.thumb, size: 60, corner: 6, placeholder: "slider.horizontal.3")
+            VStack(alignment: .leading, spacing: 2) {
+                Text(playlist.title).foregroundStyle(p.label).lineLimit(1)
+                Text(songs(playlist.items.count)).font(.subheadline).foregroundStyle(p.label2)
+            }
+            Spacer(minLength: 8)
+            Tag(text: "STEMS")
+            Image(systemName: "chevron.right").font(.system(size: 14, weight: .semibold)).foregroundStyle(p.label3)
+        }
+        .frame(height: 76)
+        .contentShape(Rectangle())
+        .listRow(inset: 94, trailing: 16)
+    }
+}
+
+/// A stem playlist: lives on this device, and every song plays with its saved mix.
+struct StemPlaylistScreen: View {
+    let id: String
+    @Environment(Ui.self) private var ui
+    @Environment(\.palette) private var p
+    @State private var editing = false
+    @State private var items: [StemPlaylistItem] = []
+    private var g: AppGraph { .shared }
+
+    var body: some View {
+        if let pl = g.stemPlaylists.list(id) {
+            page(pl)
+        } else {
+            EmptyState(icon: "slider.horizontal.3", title: "Playlist Gone", message: "This stem playlist was deleted.")
+        }
+    }
+
+    private func page(_ pl: StemPlaylist) -> some View {
+        Group {
+            if editing {
+                List {
+                    header(pl).listRowBackground(Color.clear).listRowSeparator(.hidden)
+                    ForEach(items) { it in
+                        TrackRow(track: it.track, subtitle: StemPlaylists.label(it.mix)) {}.listRowBackground(p.bg)
+                    }
+                    .onDelete { items.remove(atOffsets: $0) }
+                    .onMove { items.move(fromOffsets: $0, toOffset: $1) }
+                }
+                .listStyle(.plain)
+                .scrollContentBackground(.hidden)
+                .background(p.bg)
+                .environment(\.editMode, .constant(.active))
+                .navigationTitle(pl.title)
+                .navigationBarTitleDisplayMode(.inline)
+            } else {
+                Page(title: pl.title, large: false) {
+                    header(pl)
+                    if pl.items.isEmpty {
+                        EmptyState(icon: "slider.horizontal.3", title: "No Songs",
+                                   message: "Hold any song, album or playlist and choose “Add to Stem Playlist”.")
+                    }
+                    ForEach(Array(pl.items.enumerated()), id: \.element.id) { i, it in
+                        TrackRow(track: it.track, subtitle: "\(it.track.artist) · \(StemPlaylists.label(it.mix))", menu: ui.menu.stemItem(it, in: pl.id)) {
+                            g.playback.playTracks(pl.tracks, mixes: pl.mixes, start: i)
+                        }
+                        .listRow(inset: MARGIN + 60)
+                    }
+                }
+            }
+        }
+        .toolbar {
+            ToolbarItemGroup(placement: .topBarTrailing) {
+                if editing { Button("Done") { g.stemPlaylists.setItems(pl.id, items); editing = false }.bold() }
+                else if !pl.items.isEmpty { Button("Edit") { items = pl.items; editing = true } }
+                if !editing { MoreMenu(items: moreItems(pl)) }
+            }
+        }
+    }
+
+    private func header(_ pl: StemPlaylist) -> some View {
+        VStack(spacing: 0) {
+            Artwork(thumb: pl.thumb, size: 230, corner: 10, placeholder: "slider.horizontal.3")
+            Text(pl.title).font(.title2.bold()).foregroundStyle(p.label).multilineTextAlignment(.center).lineLimit(2)
+                .padding(.horizontal, 32).padding(.top, 14)
+            Text(pl.items.isEmpty ? "Stem Playlist" : "\(songs(pl.items.count)) · \(formatMinutes(pl.durationMs))").font(.subheadline).foregroundStyle(p.label2)
+            if !editing && !pl.items.isEmpty {
+                PlayShuffle(play: { g.playback.playTracks(pl.tracks, mixes: pl.mixes) },
+                            shuffle: { g.playback.playTracks(pl.tracks, mixes: pl.mixes, shuffle: true) }).padding(.top, 14)
+            }
+        }
+        .frame(maxWidth: .infinity)
+        .padding(.top, 8).padding(.bottom, 16)
+    }
+
+    private func moreItems(_ pl: StemPlaylist) -> [SheetAction] {
+        let lists = g.stemPlaylists
+        let rename = SheetAction("Rename…", icon: "pencil") {
+            ui.overlays.prompt("Rename Stem Playlist", nil, initial: pl.title, "Save") { lists.rename(pl.id, $0) }
+        }
+        let mixAll = SheetAction("Set Mix for All Songs…", icon: "slider.horizontal.3") {
+            ui.menu.chooseMix(pl.tracks) { m in lists.setItems(pl.id, pl.items.map { var it = $0; it.mix = MixPresets.normalized(m); return it }) }
+        }
+        return ui.menu.stemPlaylist(pl, extra: pl.items.isEmpty ? [rename] : [rename, mixAll], onPage: true)
+    }
 }
 
 struct PlaylistRow: View {

ios/Stemify/UI/Screens/SettingsScreens.swift

@@ -30,6 +30,32 @@ private struct ToggleCell: View {
     }
 }
 
+/// How quiet karaoke's Soft vocals are.
+private struct SoftVocalsCell: View {
+    @Environment(\.palette) private var p
+    private var g: AppGraph { .shared }
+    var body: some View {
+        let db = g.settings.karaokeSoftDb
+        VStack(alignment: .leading, spacing: 8) {
+            HStack(spacing: 14) {
+                SettingsIcon(symbol: "music.mic", bg: 0xFA2D48)
+                Text("Karaoke Soft Vocals").foregroundStyle(p.label)
+                Spacer()
+                Text("\(db) dB").monospacedDigit().foregroundStyle(p.label2)
+            }
+            Slider(value: Binding(get: { Double(db) }, set: { g.playback.setKaraokeSoftDb(Int($0.rounded())) }), in: -30...(-3), step: 1) {
+                Text("Karaoke Soft Vocals")
+            } minimumValueLabel: {
+                Text("Quieter").font(.caption).foregroundStyle(p.label2)
+            } maximumValueLabel: {
+                Text("Louder").font(.caption).foregroundStyle(p.label2)
+            }
+        }
+        .padding(.vertical, 4)
+        .themedRow()
+    }
+}
+
 /// A tappable row in the accent (or red), optionally centred.
 private struct ActionCell: View {
     let title: String
@@ -115,6 +141,7 @@ struct SettingsScreen: View {
                 NavCell(title: "Equalizer", value: !g.eq.state.enabled ? "Off" : g.eq.active?.name ?? "On", icon: "slider.vertical.3", iconBg: 0x34C759, route: .Eq)
                 NavCell(title: "Stem Quality", value: s.stemQuality.label, icon: "gauge.with.dots.needle.67percent", iconBg: 0xFF2D55, route: .Quality)
                 ToggleCell(title: "Keep Stem Mix Between Songs", icon: "speaker.wave.2.fill", iconBg: 0x5856D6, isOn: $s.keepStemMix)
+                SoftVocalsCell()
             } header: { Header(text: "Sound") }
             Section {
                 NavCell(title: "Cache & Downloads", value: gb(g.cache.usage.cachedBytes), icon: "externaldrive.fill", iconBg: 0x8E8E93, route: .Storage)

ios/project.yml

@@ -6,8 +6,8 @@ options:
 settings:
   base:
     SWIFT_VERSION: "5.0"
-    MARKETING_VERSION: "1.0.6"
+    MARKETING_VERSION: "1.0.8"
-    CURRENT_PROJECT_VERSION: "7"
+    CURRENT_PROJECT_VERSION: "9"
 targets:
   Stemify:
     type: application

ios/source.json

@@ -15,6 +15,24 @@
       "tintColor": "#FA2D48",
       "category": "entertainment",
       "versions": [
+        {
+          "version": "1.0.7",
+          "buildVersion": "8",
+          "date": "2026-10-20T09:39:03-07:00",
+          "localizedDescription": "- Mini player now sits in the tab bar's Liquid Glass accessory on iOS 26.1 and later, like Music. The tab bar shrinks when you scroll down and the player collapses to title and play/pause. Older iOS keeps the floating card.\n- Settings > Sound > Karaoke Soft Vocals: set how quiet Soft vocals are (-30 to -3 dB, default -12).\n\nUnsigned IPA: sideload with AltStore, SideStore or Feather.",
+          "downloadURL": "https://git.iamchrisama.com/cdnutter/stemify/releases/download/ios-v1.0.7/stemify-1.0.7.ipa",
+          "size": 1390623,
+          "minOSVersion": "17.0"
+        },
+        {
+          "version": "1.0.6",
+          "buildVersion": "7",
+          "date": "2026-10-20T09:31:01-07:00",
+          "localizedDescription": "- Karaoke vocals option on the lyrics panel: On (full vocals), Soft (vocals about 12 dB down as a guide), Off (no vocals). Remembered between songs and launches.\n\nUnsigned IPA: sideload with AltStore, SideStore or Feather.",
+          "downloadURL": "https://git.iamchrisama.com/cdnutter/stemify/releases/download/ios-v1.0.6/stemify-1.0.6.ipa",
+          "size": 1375443,
+          "minOSVersion": "17.0"
+        },
         {
           "version": "1.0.5",
           "buildVersion": "6",