diff --git a/Cargo.lock b/Cargo.lock
index 33262a1..191e793 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1280,7 +1280,7 @@ dependencies = [
 
 [[package]]
 name = "flex"
-version = "0.18.0"
+version = "0.19.0"
 dependencies = [
  "anyhow",
  "chrono",
@@ -1304,7 +1304,7 @@ dependencies = [
 
 [[package]]
 name = "flex-anilist"
-version = "0.18.0"
+version = "0.19.0"
 dependencies = [
  "flex-plugin",
  "ureq",
@@ -1312,7 +1312,7 @@ dependencies = [
 
 [[package]]
 name = "flex-core"
-version = "0.18.0"
+version = "0.19.0"
 dependencies = [
  "anyhow",
  "directories",
@@ -1337,7 +1337,7 @@ dependencies = [
 
 [[package]]
 name = "flex-lotus-lamp"
-version = "0.18.0"
+version = "0.19.0"
 dependencies = [
  "flex-plugin",
  "lotus-lamp",
@@ -1346,7 +1346,7 @@ dependencies = [
 
 [[package]]
 name = "flex-plugin"
-version = "0.18.0"
+version = "0.19.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -1354,7 +1354,7 @@ dependencies = [
 
 [[package]]
 name = "flex-trakt"
-version = "0.18.0"
+version = "0.19.0"
 dependencies = [
  "flex-plugin",
  "ureq",
@@ -1362,7 +1362,7 @@ dependencies = [
 
 [[package]]
 name = "flex-web"
-version = "0.18.0"
+version = "0.19.0"
 dependencies = [
  "anyhow",
  "axum",
diff --git a/Cargo.toml b/Cargo.toml
index 2b6d4f3..87cbd6a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,7 +6,7 @@ default-members = ["crates/*"]
 
 [workspace.package]
 edition = "2024"
-version = "0.18.0"
+version = "0.19.0"
 license = "MIT"
 
 [profile.release]
diff --git a/README.md b/README.md
index 6543737..0511c2d 100644
--- a/README.md
+++ b/README.md
@@ -75,8 +75,11 @@ date, since YouTube changes things a lot and a newer yt-dlp is usually the fix.
 
 Add channels under Channels by pasting a link or an @handle, or import your existing
 subscriptions from Google Takeout (`subscriptions.csv`), FreeTube, NewPipe or an OPML
-file. New videos are picked up from each channel's feed every half an hour, so there's no
-API key to set up. Search works too, either on the YouTube page or from the main search
+file. New videos are picked up from each channel's feed every half an hour (or press
+Refresh), so there's no API key to set up. The Showing button switches between all your
+channels, just the focused ones, and *for you*: suggestions made from the related videos
+of what you've played lately and your subscriptions' new videos, leaving out anything
+you've watched. Search works too, either on the YouTube page or from the main search
 (pick the YouTube scope at the top of the results). History lists the videos you've
 played, most recent first.
 
diff --git a/crates/flex-app/Cargo.toml b/crates/flex-app/Cargo.toml
index 48512e6..311c843 100644
--- a/crates/flex-app/Cargo.toml
+++ b/crates/flex-app/Cargo.toml
@@ -9,9 +9,9 @@ anyhow = "1.0.104"
 chrono = { version = "0.4.45", default-features = false, features = ["clock"] }
 eframe = { version = "0.36", default-features = false, features = ["glow", "default_fonts"] }
 env_logger = "0.11.11"
-flex-core = { version = "0.18.0", path = "../flex-core" }
-flex-plugin = { version = "0.18.0", path = "../flex-plugin" }
-flex-web = { version = "0.18.0", path = "../flex-web" }
+flex-core = { version = "0.19.0", path = "../flex-core" }
+flex-plugin = { version = "0.19.0", path = "../flex-plugin" }
+flex-web = { version = "0.19.0", path = "../flex-web" }
 image = { version = "0.25", default-features = false, features = ["jpeg", "png", "webp"] }
 libloading = "0.9"
 log = "0.4.34"
diff --git a/crates/flex-app/src/screens/search.rs b/crates/flex-app/src/screens/search.rs
index 3f269b2..384fe96 100644
--- a/crates/flex-app/src/screens/search.rs
+++ b/crates/flex-app/src/screens/search.rs
@@ -87,7 +87,7 @@ impl SearchView {
 
     fn open(&self, sh: &mut Shared, i: usize) -> Nav {
         match &self.results[i].target {
-            Target::Show { library_id, show_id } => Nav::push(TitlePage::new(*library_id, *show_id)),
+            Target::Show { library_id, show_id, .. } => Nav::push(TitlePage::new(*library_id, *show_id)),
             Target::Episode { library_id, file_id } => Nav::push(EpisodePage::new(*library_id, *file_id)),
             Target::Folder { library_id, rel } => open_folder(sh, *library_id, rel),
             Target::File { library_id, file_id } => open_file(sh, *library_id, *file_id),
@@ -129,7 +129,7 @@ impl Screen for SearchView {
         if press.is(Action::Menu) {
             let Some(item) = self.results.get(self.list.selected) else { return Nav::None };
             let target = match &item.target {
-                Target::Show { library_id, show_id } => return Nav::push(super::shows::ShowOptions::new(*library_id, *show_id)),
+                Target::Show { library_id, show_id, .. } => return Nav::push(super::shows::ShowOptions::new(*library_id, *show_id)),
                 Target::Folder { library_id, rel } => options::Target::Folder { library_id: *library_id, rel: rel.clone() },
                 Target::File { library_id, file_id } | Target::Episode { library_id, file_id } => {
                     options::Target::File { library_id: *library_id, file_id: *file_id }
@@ -193,8 +193,13 @@ impl Screen for SearchView {
             .iter()
             .map(|item| {
                 let icon = match item.target {
-                    Target::Show { .. } | Target::Folder { .. } | Target::Album { .. } | Target::Artist { .. } => Icon::Folder,
-                    Target::Episode { .. } | Target::File { .. } | Target::Track { .. } => Icon::Video,
+                    Target::Show { series: true, .. } => Icon::Tv,
+                    Target::Show { series: false, .. } => Icon::Film,
+                    Target::Folder { .. } => Icon::Folder,
+                    Target::Album { .. } => Icon::Album,
+                    Target::Artist { .. } => Icon::Person,
+                    Target::Track { .. } => Icon::Note,
+                    Target::Episode { .. } | Target::File { .. } => Icon::Video,
                 };
                 Row::new(icon, item.title.as_str()).detail(item.context.as_str())
             })
diff --git a/crates/flex-app/src/screens/youtube.rs b/crates/flex-app/src/screens/youtube.rs
index e7ff625..600bccb 100644
--- a/crates/flex-app/src/screens/youtube.rs
+++ b/crates/flex-app/src/screens/youtube.rs
@@ -227,17 +227,30 @@ fn video_input(input: GridInput, items: &[VideoItem]) -> Option<Nav> {
     })
 }
 
-/// YouTube's main page: part-watched videos, then the latest from subscriptions.
+/// YouTube's main page: part-watched videos, then the latest from subscriptions (or
+/// suggestions, "for you").
 #[derive(Default)]
 pub struct YouTubeHome {
     view: VideoGrid,
     items: Vec<VideoItem>,
     loaded: Option<u64>,
+    /// Suggestions are on but there's nothing played or subscribed to suggest from.
+    no_seeds: bool,
 }
 
-/// Search, Channels, History, and which channels' videos to show.
-fn home_buttons(sh: &Shared) -> [&'static str; 4] {
-    ["Search…", "Channels", "History", if sh.youtube_focused_only() { "Showing: focused" } else { "Showing: all channels" }]
+/// Search, Channels, History, Refresh, and which channels' videos to show.
+fn home_buttons(sh: &Shared) -> [&'static str; 5] {
+    [
+        "Search…",
+        "Channels",
+        "History",
+        if sh.youtube.refreshing { "Refreshing…" } else { "Refresh" },
+        match (sh.youtube_for_you(), sh.youtube_focused_only()) {
+            (true, _) => "Showing: for you",
+            (false, true) => "Showing: focused",
+            (false, false) => "Showing: all channels",
+        },
+    ]
 }
 
 impl YouTubeHome {
@@ -261,7 +274,13 @@ impl YouTubeHome {
             })
             .collect();
         let continuing: Vec<String> = items.iter().map(|v| v.id.clone()).collect();
-        items.extend(from_store(sh.yt_latest(LATEST), &progress).into_iter().filter(|v| !continuing.contains(&v.id)));
+        let rest = if sh.youtube_for_you() {
+            let suggested = sh.youtube.for_you.as_ref().and_then(|r| r.as_ref().ok());
+            from_listed(suggested.map_or(&[], Vec::as_slice), &progress).into_iter().filter(|v| !v.watched).collect()
+        } else {
+            from_store(sh.yt_latest(LATEST), &progress)
+        };
+        items.extend(rest.into_iter().filter(|v| !continuing.contains(&v.id)));
         self.items = items;
     }
 }
@@ -276,9 +295,23 @@ impl Screen for YouTubeHome {
             GridInput::Button(0) => Nav::push(TextEntry::youtube_search()),
             GridInput::Button(1) => Nav::push(ChannelList::default()),
             GridInput::Button(2) => Nav::push(YouTubeHistory::default()),
+            GridInput::Button(3) => {
+                sh.refresh_youtube_feeds();
+                if sh.youtube_for_you() {
+                    self.no_seeds = !sh.find_youtube_for_you(true);
+                }
+                Nav::None
+            }
             GridInput::Button(_) => {
-                let on = !sh.youtube_focused_only();
-                sh.set_youtube_focused_only(on);
+                // All channels → focused → for you → all channels.
+                if sh.youtube_for_you() {
+                    sh.set_youtube_for_you(false);
+                    sh.set_youtube_focused_only(false);
+                } else if sh.youtube_focused_only() {
+                    sh.set_youtube_for_you(true);
+                } else {
+                    sh.set_youtube_focused_only(true);
+                }
                 Nav::None
             }
             input => video_input(input, &self.items).unwrap_or(Nav::None),
@@ -286,11 +319,17 @@ impl Screen for YouTubeHome {
     }
 
     fn ui(&mut self, ui: &mut Ui, sh: &mut Shared, rect: Rect, focused: bool) -> Nav {
+        let for_you = sh.youtube_for_you();
+        // With nothing to suggest from, try again only once something changes.
+        if for_you && sh.youtube.tools.is_some() && (!self.no_seeds || self.loaded != Some(sh.youtube.version)) {
+            self.no_seeds = !sh.find_youtube_for_you(false);
+        }
         self.refresh(sh);
         let channels = sh.yt_channels().len();
         let subtitle = match (sh.youtube.tools.is_some(), channels, sh.youtube.refreshing) {
             (false, _, _) if sh.youtube.tools_busy => "Setting up (downloading yt-dlp)…".to_owned(),
             (false, _, _) => "Not set up: switch YouTube on in Settings → YouTube".to_owned(),
+            (true, _, _) if for_you && sh.youtube.for_you_busy => "Finding videos for you…".to_owned(),
             (true, 0, _) => "Search, or subscribe to channels in Channels".to_owned(),
             (true, n, true) => format!("{} · checking for new videos…", count(n, "channel")),
             (true, n, false) => format!("{} · no ads, sponsors skipped", count(n, "channel")),
@@ -298,6 +337,10 @@ impl Screen for YouTubeHome {
         let body = widgets::header(ui.painter(), rect, "YouTube", &subtitle, ui.style());
         let items = std::mem::take(&mut self.items);
         let empty = match (channels, sh.youtube_focused_only()) {
+            _ if for_you && sh.youtube.for_you_busy => "Finding videos for you…",
+            _ if for_you && self.no_seeds => "Play a few videos or subscribe to channels, and suggestions will show here",
+            _ if for_you && matches!(sh.youtube.for_you, Some(Err(_))) => "Couldn't get suggestions from YouTube. Try Refresh",
+            _ if for_you => "No suggestions yet. Try Refresh",
             (0, _) => "Nothing here yet",
             (_, true) if !sh.yt_channels().iter().any(|c| c.focused) => "No focused channels yet: hold OK on one in Channels",
             _ => "No new videos",
diff --git a/crates/flex-app/src/shared.rs b/crates/flex-app/src/shared.rs
index ac20891..2d63605 100644
--- a/crates/flex-app/src/shared.rs
+++ b/crates/flex-app/src/shared.rs
@@ -1699,6 +1699,37 @@ impl Shared {
         self.setting_bool(crate::youtube::FOCUSED_SETTING)
     }
 
+    /// Whether YouTube's page shows suggestions instead of subscriptions' videos.
+    pub fn youtube_for_you(&self) -> bool {
+        self.setting_bool(crate::youtube::FOR_YOU_SETTING)
+    }
+
+    pub fn set_youtube_for_you(&mut self, on: bool) {
+        self.set_setting_bool(crate::youtube::FOR_YOU_SETTING, on);
+        self.youtube.version += 1;
+    }
+
+    /// Finds suggestions for YouTube's page if they're due (or now with `force`), from
+    /// recently played videos and subscriptions' new ones. Returns false if there's
+    /// nothing to start from.
+    pub fn find_youtube_for_you(&mut self, force: bool) -> bool {
+        use flex_core::youtube::recommend;
+        if !force && !self.youtube.for_you_due() {
+            return true;
+        }
+        let progress = self.yt_progress_all();
+        let history = self.db.yt_history(20).unwrap_or_default();
+        let latest = self.db.yt_latest(20, false, false).unwrap_or_default();
+        let seeds = recommend::seeds(&history, &latest, &progress);
+        if seeds.is_empty() {
+            return false;
+        }
+        let watched = progress.into_iter().filter(|(_, p)| p.watched).map(|(id, _)| id).collect();
+        let subscribed = self.yt_channels().into_iter().map(|c| c.id).collect();
+        self.youtube.start_for_you(seeds, watched, subscribed, self.youtube_shorts());
+        true
+    }
+
     pub fn set_youtube_focused_only(&mut self, on: bool) {
         self.set_setting_bool(crate::youtube::FOCUSED_SETTING, on);
         self.youtube.version += 1;
@@ -1811,8 +1842,7 @@ impl Shared {
             }
         }
         self.youtube.version += 1;
-        let ids = self.yt_channels().into_iter().map(|c| c.id).collect();
-        self.youtube.refresh(ids);
+        self.refresh_youtube_feeds();
         Ok(added)
     }
 
@@ -1837,15 +1867,20 @@ impl Shared {
                 Msg::Tools(Err(e)) => self.toast(format!("Couldn't set up YouTube: {e}")),
                 Msg::Channel(Ok((id, title))) => self.subscribe(&id, &title),
                 Msg::Channel(Err(e)) => self.toast(format!("Couldn't find that channel: {e}")),
-                Msg::Resolved(..) | Msg::Segments(..) | Msg::Search(..) | Msg::Related(..) => {}
+                Msg::Resolved(..) | Msg::Segments(..) | Msg::Search(..) | Msg::Related(..) | Msg::ForYou(..) => {}
             }
         }
         if self.youtube_enabled() && self.youtube.tools.is_some() && self.youtube.refresh_due() {
-            let ids = self.yt_channels().into_iter().map(|c| c.id).collect();
-            self.youtube.refresh(ids);
+            self.refresh_youtube_feeds();
         }
     }
 
+    /// Reads every subscription's feed again now (in the background).
+    pub fn refresh_youtube_feeds(&mut self) {
+        let ids = self.yt_channels().into_iter().map(|c| c.id).collect();
+        self.youtube.refresh(ids);
+    }
+
     /// Handles plugin messages, tells plugins about playback, keeps the computer awake
     /// while something plays and updates lights.
     /// `playing`: what the top screen is playing, if anything, and the library file.
@@ -2171,7 +2206,7 @@ impl Shared {
                         Some(y) => format!("{} · {y}", l.lib.name),
                         None => l.lib.name.clone(),
                     };
-                    let target = Target::Show { library_id: l.lib.id, show_id: entry.show.id };
+                    let target = Target::Show { library_id: l.lib.id, show_id: entry.show.id, series: entry.is_series() };
                     items.push(Item::new(entry.show.title.clone(), context, target, 0, &also));
                     if entry.is_series() {
                         for e in &entry.episodes {
@@ -2200,7 +2235,7 @@ impl Shared {
             .into_iter()
             .filter_map(|item| {
                 let (library, show, file) = match item.target {
-                    Target::Show { library_id, show_id } => (library_id, Some(show_id), None),
+                    Target::Show { library_id, show_id, .. } => (library_id, Some(show_id), None),
                     Target::Episode { library_id, file_id } | Target::File { library_id, file_id } => (library_id, None, Some(file_id)),
                     _ => return None,
                 };
diff --git a/crates/flex-app/src/widgets.rs b/crates/flex-app/src/widgets.rs
index 6bb0694..544829b 100644
--- a/crates/flex-app/src/widgets.rs
+++ b/crates/flex-app/src/widgets.rs
@@ -17,6 +17,14 @@ pub enum Icon {
     Refresh,
     Remove,
     Star,
+    /// A film reel.
+    Film,
+    Tv,
+    /// A record, for albums.
+    Album,
+    Person,
+    /// A musical note, for tracks.
+    Note,
 }
 
 pub struct Row {
@@ -140,6 +148,37 @@ pub fn paint_icon(painter: &Painter, c: Pos2, icon: Icon, color: Color32) {
                 painter.add(egui::Shape::convex_polygon(points, color, Stroke::NONE));
             }
         }
+        Icon::Film => {
+            painter.circle_stroke(c, 13.0, Stroke::new(3.0, color));
+            painter.circle_filled(c, 2.5, color);
+            for i in 0..5 {
+                let a = (-90.0 + 72.0 * i as f32).to_radians();
+                painter.circle_filled(c + vec2(a.cos(), a.sin()) * 7.0, 2.5, color);
+            }
+            // The film running off the reel.
+            painter.line_segment([c + vec2(0.0, 13.0), c + vec2(16.0, 13.0)], Stroke::new(3.0, color));
+        }
+        Icon::Tv => {
+            let screen = Rect::from_center_size(c + vec2(0.0, 3.0), vec2(30.0, 20.0));
+            painter.rect_stroke(screen, 3, Stroke::new(3.0, color), egui::StrokeKind::Inside);
+            let top = c + vec2(0.0, -7.0);
+            painter.line_segment([top, c + vec2(-6.0, -14.0)], Stroke::new(2.5, color));
+            painter.line_segment([top, c + vec2(6.0, -14.0)], Stroke::new(2.5, color));
+        }
+        Icon::Album => {
+            painter.circle_stroke(c, 12.5, Stroke::new(4.0, color));
+            painter.circle_filled(c, 4.0, color);
+        }
+        Icon::Person => {
+            painter.circle_filled(c + vec2(0.0, -7.0), 6.5, color);
+            let body = Rect::from_min_max(c + vec2(-12.0, 2.0), c + vec2(12.0, 14.0));
+            painter.rect_filled(body, egui::CornerRadius { nw: 11, ne: 11, sw: 2, se: 2 }, color);
+        }
+        Icon::Note => {
+            painter.circle_filled(c + vec2(-5.0, 8.0), 5.5, color);
+            painter.line_segment([c + vec2(0.0, 8.0), c + vec2(0.0, -13.0)], Stroke::new(3.0, color));
+            painter.line_segment([c + vec2(-1.5, -13.0), c + vec2(9.0, -7.0)], Stroke::new(3.5, color));
+        }
     }
 }
 
diff --git a/crates/flex-app/src/youtube.rs b/crates/flex-app/src/youtube.rs
index 500fae8..c0ddb2f 100644
--- a/crates/flex-app/src/youtube.rs
+++ b/crates/flex-app/src/youtube.rs
@@ -8,7 +8,7 @@ use std::time::{Duration, Instant};
 
 use eframe::egui;
 use flex_core::youtube::feeds::{self, FeedVideo, Listed};
-use flex_core::youtube::related;
+use flex_core::youtube::{recommend, related};
 use flex_core::youtube::sponsorblock::{self, Segment};
 use flex_core::youtube::tools::{self, Tool};
 use flex_core::youtube::{Tools, Video};
@@ -22,6 +22,8 @@ pub const SPONSORBLOCK_SETTING: &str = "youtube_sponsorblock";
 pub const CONTINUE_SETTING: &str = "youtube_continue";
 /// Whether YouTube's page shows only focused channels' videos.
 pub const FOCUSED_SETTING: &str = "youtube_focused_only";
+/// Whether YouTube's page shows suggestions ("for you") instead of subscriptions' videos.
+pub const FOR_YOU_SETTING: &str = "youtube_for_you";
 /// How many part-watched videos Continue Watching keeps, as offered in Settings.
 pub const CONTINUE_LIMITS: [usize; 5] = [0, 3, 5, 10, 20];
 pub const DEFAULT_CONTINUE: usize = 10;
@@ -33,6 +35,8 @@ pub const DEFAULT_QUALITY: u32 = 1080;
 const RESOLVED_FOR: Duration = Duration::from_secs(2 * 3600);
 /// How often subscriptions' feeds are read again.
 const REFRESH_EVERY: Duration = Duration::from_secs(30 * 60);
+/// How long suggestions last before they're found again.
+const FOR_YOU_EVERY: Duration = Duration::from_secs(3600);
 /// A pause between feeds, to be gentle with YouTube.
 const FEED_GAP: Duration = Duration::from_millis(300);
 
@@ -49,6 +53,8 @@ pub enum Msg {
     Related(String, Result<Vec<Listed>, String>),
     /// "Add a channel": its id and name.
     Channel(Result<(String, String), String>),
+    /// Suggestions for YouTube's page.
+    ForYou(Result<Vec<Listed>, String>),
 }
 
 /// A search (or a video's related videos): the query (or video), and its results once in.
@@ -70,6 +76,10 @@ pub struct YouTube {
     pub related: Option<Search>,
     pub refreshing: bool,
     last_refresh: Option<Instant>,
+    /// Suggestions once found (or why not), and whether they're being found now.
+    pub for_you: Option<Result<Vec<Listed>, String>>,
+    pub for_you_busy: bool,
+    for_you_at: Option<Instant>,
     /// Bumped when subscriptions or their videos change, so screens reload.
     pub version: u64,
 }
@@ -90,6 +100,9 @@ impl YouTube {
             related: None,
             refreshing: false,
             last_refresh: None,
+            for_you: None,
+            for_you_busy: false,
+            for_you_at: None,
             version: 0,
         }
     }
@@ -222,6 +235,44 @@ impl YouTube {
         });
     }
 
+    /// Whether suggestions should be found (again).
+    pub fn for_you_due(&self) -> bool {
+        !self.for_you_busy && self.for_you_at.is_none_or(|t| t.elapsed() >= FOR_YOU_EVERY)
+    }
+
+    /// Finds suggestions in the background from each seed's related videos (see
+    /// [`recommend`]). Fails only if every seed's related videos did.
+    pub fn start_for_you(&mut self, seeds: Vec<(String, f32)>, exclude: HashSet<String>, subscribed: HashSet<String>, shorts: bool) {
+        if self.for_you_busy {
+            return;
+        }
+        self.for_you_busy = true;
+        self.for_you_at = Some(Instant::now());
+        self.spawn(move |tx| {
+            let results: Vec<(f32, anyhow::Result<Vec<Listed>>)> = std::thread::scope(|s| {
+                let handles: Vec<_> = seeds.iter().map(|(id, weight)| (*weight, s.spawn(move || related::related(id)))).collect();
+                handles.into_iter().map(|(w, h)| (w, h.join().unwrap_or_else(|_| Err(anyhow::anyhow!("panicked"))))).collect()
+            });
+            let mut lists = Vec::new();
+            let mut error = None;
+            for (weight, result) in results {
+                match result {
+                    Ok(list) => lists.push((weight, list)),
+                    Err(e) => error = Some(format!("{e:#}")),
+                }
+            }
+            let result = match error {
+                Some(e) if lists.is_empty() => Err(e),
+                _ => {
+                    let mut exclude = exclude;
+                    exclude.extend(seeds.into_iter().map(|(id, _)| id));
+                    Ok(recommend::rank(&lists, &exclude, &subscribed, shorts))
+                }
+            };
+            let _ = tx.send(Msg::ForYou(result));
+        });
+    }
+
     /// Looks up a channel from a link or @handle (then subscribes, see `Shared`).
     pub fn find_channel(&self, input: &str) {
         let Some(tools) = self.tools.clone() else { return };
@@ -268,6 +319,14 @@ impl YouTube {
                     self.refreshing = false;
                     out.push(Msg::FeedsDone);
                 }
+                Msg::ForYou(result) => {
+                    if let Err(e) = &result {
+                        log::warn!("youtube: no suggestions: {e}");
+                    }
+                    self.for_you_busy = false;
+                    self.for_you = Some(result);
+                    self.version += 1;
+                }
                 other => out.push(other),
             }
         }
diff --git a/crates/flex-core/Cargo.toml b/crates/flex-core/Cargo.toml
index 996eca9..96bada8 100644
--- a/crates/flex-core/Cargo.toml
+++ b/crates/flex-core/Cargo.toml
@@ -7,7 +7,7 @@ publish = false
 [dependencies]
 anyhow = "1.0.104"
 directories = "6.0.0"
-flex-plugin = { version = "0.18.0", path = "../flex-plugin" }
+flex-plugin = { version = "0.19.0", path = "../flex-plugin" }
 hunch = "2"
 lofty = "0.25.4"
 log = "0.4.34"
diff --git a/crates/flex-core/src/search.rs b/crates/flex-core/src/search.rs
index ab707bb..75411fc 100644
--- a/crates/flex-core/src/search.rs
+++ b/crates/flex-core/src/search.rs
@@ -11,8 +11,8 @@ use crate::tree::Tree;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Target {
-    /// A show or film (opens its page).
-    Show { library_id: i64, show_id: i64 },
+    /// A show or film (opens its page). `series` when it has episodes.
+    Show { library_id: i64, show_id: i64, series: bool },
     /// An episode (opens its page).
     Episode { library_id: i64, file_id: i64 },
     Folder { library_id: i64, rel: String },
@@ -249,7 +249,7 @@ mod tests {
         );
         let mut items = path_items(&lib, &tree);
         let show = |id, title: &str, also: &[String]| {
-            Item::new(title.into(), "Anime".into(), Target::Show { library_id: 1, show_id: id }, 0, also)
+            Item::new(title.into(), "Anime".into(), Target::Show { library_id: 1, show_id: id, series: true }, 0, also)
         };
         items.push(show(10, "Dorohedoro", &[]));
         items.push(show(11, "Attack on Titan", &["Shingeki no Kyojin".to_owned()]));
diff --git a/crates/flex-core/src/youtube/mod.rs b/crates/flex-core/src/youtube/mod.rs
index 7d9b07f..4705f3f 100644
--- a/crates/flex-core/src/youtube/mod.rs
+++ b/crates/flex-core/src/youtube/mod.rs
@@ -7,6 +7,7 @@
 
 pub mod feeds;
 pub mod proxy;
+pub mod recommend;
 pub mod related;
 pub mod sponsorblock;
 pub mod store;
diff --git a/crates/flex-core/src/youtube/recommend.rs b/crates/flex-core/src/youtube/recommend.rs
new file mode 100644
index 0000000..6fe349f
--- /dev/null
+++ b/crates/flex-core/src/youtube/recommend.rs
@@ -0,0 +1,139 @@
+//! "For you" without an account: videos related to what was played lately and to
+//! subscriptions' new videos, ranked by how strongly those suggest them.
+
+use std::collections::{HashMap, HashSet};
+
+use super::feeds::Listed;
+use super::store::{Video, WatchProgress};
+
+/// How many recently played videos, and subscriptions' new videos, to start from.
+const FROM_HISTORY: usize = 6;
+const FROM_SUBSCRIPTIONS: usize = 4;
+/// Each older played video counts this much less than the one after it.
+const RECENCY_DECAY: f32 = 0.85;
+/// At most this many videos from one channel, so one channel doesn't fill the page.
+const PER_CHANNEL: usize = 3;
+/// Videos from subscribed channels count this much more.
+const SUBSCRIBED_BONUS: f32 = 1.25;
+/// Shorter than this (seconds) counts as a Short.
+const SHORT_SECS: f64 = 60.0;
+
+/// The videos to ask for related videos of, with how much each counts: recently played
+/// ones (more if watched through, less if given up on early), then subscriptions' newest
+/// unwatched videos. `history` is most recent first, `latest` newest first.
+pub fn seeds(history: &[(String, WatchProgress)], latest: &[Video], progress: &HashMap<String, WatchProgress>) -> Vec<(String, f32)> {
+    let mut out: Vec<(String, f32)> = Vec::new();
+    for (i, (id, p)) in history.iter().take(FROM_HISTORY).enumerate() {
+        let fraction = match (p.position, p.duration) {
+            (Some(pos), Some(dur)) if dur > 0.0 => pos / dur,
+            _ => 0.0,
+        };
+        let interest = if p.watched { 1.0 } else if fraction > 0.3 { 0.8 } else { 0.4 };
+        out.push((id.clone(), interest * RECENCY_DECAY.powi(i as i32)));
+    }
+    let new: Vec<(String, f32)> = latest
+        .iter()
+        .filter(|v| !v.short && !progress.get(&v.id).is_some_and(|p| p.watched))
+        .filter(|v| !out.iter().any(|(id, _)| *id == v.id))
+        .take(FROM_SUBSCRIPTIONS)
+        .map(|v| (v.id.clone(), 0.6))
+        .collect();
+    out.extend(new);
+    out
+}
+
+/// Merges each seed's related videos (weight, then the list in YouTube's order) into one
+/// list. A video scores for every seed that suggests it, more near the top of that list.
+/// Leaves out `exclude` (e.g. watched videos and the seeds), Shorts unless `shorts`, and
+/// more than a few videos from one channel.
+pub fn rank(lists: &[(f32, Vec<Listed>)], exclude: &HashSet<String>, subscribed: &HashSet<String>, shorts: bool) -> Vec<Listed> {
+    let mut scores: HashMap<&str, (f32, usize, &Listed)> = HashMap::new();
+    let mut order = 0;
+    for (weight, list) in lists {
+        for (rank, video) in list.iter().enumerate() {
+            if exclude.contains(&video.id) || (!shorts && video.duration.is_some_and(|d| d <= SHORT_SECS)) {
+                continue;
+            }
+            let bonus = if subscribed.contains(&video.channel_id) { SUBSCRIBED_BONUS } else { 1.0 };
+            let score = weight * bonus / (1.0 + rank as f32 / 4.0);
+            let entry = scores.entry(&video.id).or_insert_with(|| {
+                order += 1;
+                (0.0, order, video)
+            });
+            entry.0 += score;
+        }
+    }
+    let mut ranked: Vec<(f32, usize, &Listed)> = scores.into_values().collect();
+    ranked.sort_by(|a, b| b.0.total_cmp(&a.0).then(a.1.cmp(&b.1)));
+    let mut per_channel: HashMap<&str, usize> = HashMap::new();
+    ranked
+        .into_iter()
+        .filter(|(_, _, v)| {
+            let key = if v.channel_id.is_empty() { v.channel.as_str() } else { v.channel_id.as_str() };
+            let n = per_channel.entry(key).or_default();
+            *n += 1;
+            *n <= PER_CHANNEL
+        })
+        .map(|(_, _, v)| v.clone())
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn listed(id: &str, channel: &str) -> Listed {
+        Listed { id: id.into(), title: id.into(), channel: channel.into(), channel_id: format!("UC{channel}"), duration: Some(600.0) }
+    }
+
+    fn played(id: &str, position: f64, watched: bool) -> (String, WatchProgress) {
+        let p = WatchProgress { title: id.into(), channel: "c".into(), position: Some(position), duration: Some(100.0), watched, updated_at: 0 };
+        (id.into(), p)
+    }
+
+    #[test]
+    fn suggested_by_more_seeds_ranks_higher() {
+        let lists = vec![
+            (1.0, vec![listed("a", "x"), listed("b", "y")]),
+            (1.0, vec![listed("c", "z"), listed("b", "y")]),
+        ];
+        let ids: Vec<String> = rank(&lists, &HashSet::new(), &HashSet::new(), true).into_iter().map(|v| v.id).collect();
+        assert_eq!(ids, ["b", "a", "c"]);
+    }
+
+    #[test]
+    fn leaves_out_excluded_shorts_and_too_much_of_one_channel() {
+        let mut short = listed("s", "y");
+        short.duration = Some(30.0);
+        let list = vec![listed("w", "y"), short, listed("1", "x"), listed("2", "x"), listed("3", "x"), listed("4", "x")];
+        let exclude = HashSet::from(["w".to_owned()]);
+        let ids: Vec<String> = rank(&[(1.0, list)], &exclude, &HashSet::new(), false).into_iter().map(|v| v.id).collect();
+        assert_eq!(ids, ["1", "2", "3"]);
+    }
+
+    #[test]
+    fn seeds_weigh_recent_and_finished_videos_more() {
+        let history = vec![played("given-up", 5.0, false), played("finished", 100.0, true)];
+        let latest = vec![
+            Video { id: "new".into(), title: "t".into(), channel_id: "UCx".into(), channel: "x".into(), published: 0, short: false },
+            Video { id: "finished".into(), title: "t".into(), channel_id: "UCx".into(), channel: "x".into(), published: 0, short: false },
+        ];
+        let seeds = seeds(&history, &latest, &HashMap::new());
+        let ids: Vec<&str> = seeds.iter().map(|(id, _)| id.as_str()).collect();
+        assert_eq!(ids, ["given-up", "finished", "new"]);
+        assert!(seeds[1].1 > seeds[0].1);
+    }
+
+    /// Asks YouTube for real: `cargo test -p flex-core suggests_online -- --ignored --nocapture`.
+    #[test]
+    #[ignore]
+    fn suggests_online() {
+        let lists: Vec<(f32, Vec<Listed>)> =
+            ["aqz-KE-bpKQ", "eRsGyueVLvQ"].iter().map(|id| (1.0, super::super::related::related(id).unwrap())).collect();
+        let ranked = rank(&lists, &HashSet::new(), &HashSet::new(), false);
+        for v in ranked.iter().take(10) {
+            eprintln!("{} · {} · {}", v.id, v.channel, v.title);
+        }
+        assert!(ranked.len() >= 10);
+    }
+}
diff --git a/crates/flex-web/Cargo.toml b/crates/flex-web/Cargo.toml
index 3981e3d..34ac317 100644
--- a/crates/flex-web/Cargo.toml
+++ b/crates/flex-web/Cargo.toml
@@ -7,7 +7,7 @@ publish = false
 [dependencies]
 anyhow = "1.0.104"
 axum = "0.8.9"
-flex-core = { version = "0.18.0", path = "../flex-core" }
+flex-core = { version = "0.19.0", path = "../flex-core" }
 log = "0.4.34"
 serde = { version = "1.0.229", features = ["derive", "rc"] }
 serde_json = "1.0.151"
diff --git a/plugins/anilist/Cargo.toml b/plugins/anilist/Cargo.toml
index f0ec9fd..d8474a7 100644
--- a/plugins/anilist/Cargo.toml
+++ b/plugins/anilist/Cargo.toml
@@ -7,5 +7,5 @@ license.workspace = true
 publish = false
 
 [dependencies]
-flex-plugin = { version = "0.18.0", path = "../../crates/flex-plugin" }
+flex-plugin = { version = "0.19.0", path = "../../crates/flex-plugin" }
 ureq = { version = "3", features = ["json"] }
diff --git a/plugins/anilist/plugin.toml b/plugins/anilist/plugin.toml
index b73a894..419adee 100644
--- a/plugins/anilist/plugin.toml
+++ b/plugins/anilist/plugin.toml
@@ -1,6 +1,6 @@
 name = "AniList"
 description = "Updates your AniList progress as you watch anime in Flex"
-version = "0.18.0"
+version = "0.19.0"
 command = "flex-anilist"
 subscribe = ["playback"]
 
diff --git a/plugins/lotus-lamp/Cargo.toml b/plugins/lotus-lamp/Cargo.toml
index 3bed27c..b30bb8e 100644
--- a/plugins/lotus-lamp/Cargo.toml
+++ b/plugins/lotus-lamp/Cargo.toml
@@ -7,6 +7,6 @@ license.workspace = true
 publish = false
 
 [dependencies]
-flex-plugin = { version = "0.18.0", path = "../../crates/flex-plugin" }
+flex-plugin = { version = "0.19.0", path = "../../crates/flex-plugin" }
 lotus-lamp = { git = "https://github.com/bombpersons/lotus-lamp-rs", rev = "59cf5ccaa0007f006f1812fd02cc5991aff11e72" }
 tokio = { version = "1.53.2", features = ["rt", "time", "sync", "macros"] }
diff --git a/plugins/lotus-lamp/plugin.toml b/plugins/lotus-lamp/plugin.toml
index 247e695..d345ef4 100644
--- a/plugins/lotus-lamp/plugin.toml
+++ b/plugins/lotus-lamp/plugin.toml
@@ -1,6 +1,6 @@
 name = "LED strip (Lotus Lamp)"
 description = "Lights a Bluetooth LED strip behind the TV with the colours on screen"
-version = "0.18.0"
+version = "0.19.0"
 command = "flex-lotus-lamp"
 subscribe = ["light"]
 
diff --git a/plugins/trakt/Cargo.toml b/plugins/trakt/Cargo.toml
index 54e3cd3..f654768 100644
--- a/plugins/trakt/Cargo.toml
+++ b/plugins/trakt/Cargo.toml
@@ -7,5 +7,5 @@ license.workspace = true
 publish = false
 
 [dependencies]
-flex-plugin = { version = "0.18.0", path = "../../crates/flex-plugin" }
+flex-plugin = { version = "0.19.0", path = "../../crates/flex-plugin" }
 ureq = { version = "3", features = ["json"] }
diff --git a/plugins/trakt/plugin.toml b/plugins/trakt/plugin.toml
index a70d768..1bd9032 100644
--- a/plugins/trakt/plugin.toml
+++ b/plugins/trakt/plugin.toml
@@ -1,6 +1,6 @@
 name = "Trakt"
 description = "Keeps your Trakt history up to date with what you watch in Flex"
-version = "0.18.0"
+version = "0.19.0"
 command = "flex-trakt"
 subscribe = ["playback"]