diff --git a/README.md b/README.md
index ab3155b..aa23949 100644
--- a/README.md
+++ b/README.md
@@ -141,7 +141,7 @@ remote control HTTP API, station profiles, local operator accounts.
 **Rules** say what plays (an advert / jingle folder, chosen files, or the Adverts list), how often (after every N
 songs, every N minutes or hours, or at set times) and when the rule is in force (dates, days, hours). The **Adverts
 list** holds your adverts with the dates and days each may run. Rules can also be used in the playlist generator
-(as a pattern step or inserted every N minutes) and run by the Event scheduler or the `RULE <name>` command.
+(as a pattern step) and run by the Event scheduler or the `RULE <name>` command.
 
 ## Event scheduler (Tools → Event scheduler, F3)
 At a set time (on chosen days and dates): generate a new playlist from a template, append one, play a rule's
diff --git a/assets/portal/portal.js b/assets/portal/portal.js
index e06bf9d..239b069 100644
--- a/assets/portal/portal.js
+++ b/assets/portal/portal.js
@@ -571,7 +571,7 @@ $("autoSave").addEventListener("click", () => saveCfg((c) => {
 $("tplAdd").addEventListener("click", () => editTemplate(-1));
 $("catAdd").addEventListener("click", () => editCategory(-1));
 
-/// Rows of (source, numbers…) with add and remove: template steps and markers.
+/// Rows of (source, numbers…) with add and remove: template steps.
 function stepRows(items, make, fields, addText) {
   const box = el("div");
   const draw = () => {
@@ -595,9 +595,9 @@ function stepRows(items, make, fields, addText) {
 
 function editTemplate(i) {
   const t = i >= 0 ? JSON.parse(JSON.stringify(cfg.templates[i]))
-    : { name: "New template", minutes: 120, pattern: [{ category: (cfg.categories[0] || {}).name || "Music", count: 1 }], markers: [], artist_gap: 5, hour_markers: false };
+    : { name: "New template", minutes: 120, pattern: [{ category: (cfg.categories[0] || {}).name || "Music", count: 1 }], artist_gap: 5, hour_markers: false };
   t.pattern = t.pattern || [];
-  t.markers = t.markers || [];
+  delete t.markers; // generator inserts were removed; the station's ad rules play jingles and adverts
   const first = (sources()[0] || ["Music"])[0];
   const name = el("input", { value: t.name, required: true });
   const minutes = num(t.minutes, 1, 1440 * 7);
@@ -608,8 +608,6 @@ function editTemplate(i) {
     el("div", { class: "pair" }, field("Length (minutes)", minutes), field("Songs before an artist repeats", gap)),
     el("div", { class: "sub" }, el("strong", {}, "Steps"), el("p", { class: "muted small" }, "Played in order, then again from the top, until the length is reached."),
       stepRows(t.pattern, () => ({ category: first, count: 1 }), [["count", "×", 1, 50]], "＋ Step")),
-    el("div", { class: "sub" }, el("strong", {}, "Markers"), el("p", { class: "muted small" }, "Put in every so many minutes, e.g. a station ID every 30 minutes."),
-      stepRows(t.markers, () => ({ category: first, every_mins: 30, count: 1 }), [["every_mins", "every (min)", 1, 1440], ["count", "×", 1, 20]], "＋ Marker")),
     hourRow,
   ], () => {
     const n = name.value.trim();
@@ -653,7 +651,7 @@ function editCategory(i) {
       if (k >= 0) x.categories[k] = c; else x.categories.push(c);
       // the templates follow a renamed category
       if (old !== null && old !== n) {
-        (x.templates || []).forEach((t) => [...(t.pattern || []), ...(t.markers || [])].forEach((p) => { if (p.category === old) p.category = n; }));
+        (x.templates || []).forEach((t) => (t.pattern || []).forEach((p) => { if (p.category === old) p.category = n; }));
       }
     });
   });
diff --git a/lang/template.json b/lang/template.json
index 83260f3..89aef2e 100644
--- a/lang/template.json
+++ b/lang/template.json
@@ -98,7 +98,6 @@
  "Assign audio file": "",
  "Assign audio file…": "",
  "At": "",
- "At the top of every hour": "",
  "Attack": "",
  "Audio FX": "",
  "Audio devices": "",
@@ -242,7 +241,6 @@
  "Events": "",
  "Every": "",
  "Every 30 minutes on the clock = at :00 and :30. Off = 30 minutes after the last time.": "",
- "Every 60 minutes on the clock = at the top of each hour. Off = counted from the start of the playlist.": "",
  "Every change is listed in cleanup-log.csv in the data folder.": "",
  "Every day": "",
  "Every file is there and can be read.": "",
@@ -340,7 +338,6 @@
  "Insert tracks from playlist…": "",
  "Insert voice track": "",
  "Insert voice track…": "",
- "Inserts": "",
  "Install now": "",
  "Interface size": "",
  "Intro sound": "",
@@ -350,7 +347,6 @@
  "JINGLE": "",
  "Jingles": "",
  "Jingles & adverts (their rule's files)": "",
- "Jingles, adverts, talk or a time announcement, like the advert / jingle rules: after a number of songs, every so often, or at set times. Timed ones go in after the song that's playing when the time comes.": "",
  "Keep": "",
  "Keep the music at full level": "",
  "Keep the playing track near the top as songs finish (the last one played stays in view)": "",
@@ -405,7 +401,6 @@
  "MIDI only": "",
  "MP3 (built in)": "",
  "MP3 (compressed, 64–320 kbps)": "",
- "Make a jingle rule in the Advertisement scheduler first, or add a Jingles category": "",
  "Make a tunnel in the Cloudflare dashboard (Zero Trust → Networks → Tunnels) for your own domain, and point it at http://localhost and the portal port. Without a token you get a random trycloudflare.com address.": "",
  "Make everything larger or smaller if the text is hard to read.": "",
  "Make this the primary output": "",
@@ -767,7 +762,7 @@
  "The song on air fades out and the break starts on time. A countdown lets the presenter play it now, snooze it or skip it.": "",
  "The song on air will fade out.": "",
  "The station goes quiet while the server restarts (a few seconds) — best done between shows. This app reconnects by itself.": "",
- "The template's times of day and timed inserts follow the clock from where the new tracks start.": "",
+ "The template's times of day follow the clock from where the new tracks start.": "",
  "The track is only": "",
  "There's no RadioMaster Server download for the server's system: update it by hand": "",
  "These accounts sign in to the server (from the app and the web portal). The server checks every action against them.": "",
@@ -829,7 +824,6 @@
  "Username": "",
  "Users & access control": "",
  "Users…": "",
- "Uses the files of a jingle rule (Advertisement scheduler) every 15 minutes": "",
  "Version": "",
  "Very slow computer": "",
  "View": "",
@@ -893,7 +887,6 @@
  "advert name": "",
  "advertiser / company": "",
  "adverts": "",
- "after every": "",
  "after the playlist (instead of replacing it)": "",
  "after the track on air": "",
  "all day": "",
@@ -915,7 +908,6 @@
  "e.g. station id, news": "",
  "egui · rodio · symphonia · LAME": "",
  "encoder": "",
- "every": "",
  "every advert": "",
  "failed": "",
  "files": "",
@@ -1016,7 +1008,6 @@
  "this band": "",
  "this category": "",
  "this event": "",
- "this insert": "",
  "this rule": "",
  "this shortcut": "",
  "this template": "",
@@ -1109,12 +1100,9 @@
  "➕ Add encoder": "",
  "➕ Add event": "",
  "➕ Add files": "",
- "➕ Add insert": "",
- "➕ Add jingles": "",
  "➕ Add pattern step": "",
  "➕ Add streamer": "",
  "➕ Add time": "",
- "➕ Add time announcement": "",
  "➕ Add time of day": "",
  "➕ Advert rule": "",
  "➕ Folder…": "",
diff --git a/site/guides/playlist-generator/index.html b/site/guides/playlist-generator/index.html
index d0d6a2a..84b1dde 100644
--- a/site/guides/playlist-generator/index.html
+++ b/site/guides/playlist-generator/index.html
@@ -14,7 +14,7 @@
 <meta property="og:type" content="article">
 <meta property="og:site_name" content="RadioMaster">
 <meta property="og:title" content="How to use the playlist generator">
-<meta property="og:description" content="Categories, templates, patterns, jingle inserts and auto-playlist: build hours of programming in one click.">
+<meta property="og:description" content="Categories, templates, patterns and auto-playlist: build hours of programming in one click.">
 <meta property="og:url" content="https://radiomaster.dovafm.com/guides/playlist-generator/">
 <meta property="og:image" content="https://radiomaster.dovafm.com/img/main.png">
 <meta property="og:image:width" content="1280">
@@ -23,7 +23,7 @@
 <meta property="og:locale" content="en_GB">
 <meta name="twitter:card" content="summary_large_image">
 <meta name="twitter:title" content="How to use the playlist generator">
-<meta name="twitter:description" content="Categories, templates, patterns, jingle inserts and auto-playlist: build hours of programming in one click.">
+<meta name="twitter:description" content="Categories, templates, patterns and auto-playlist: build hours of programming in one click.">
 <meta name="twitter:image" content="https://radiomaster.dovafm.com/img/main.png">
 <script type="application/ld+json">
 {
@@ -114,7 +114,7 @@
     <p class="eyebrow">Guide · Run the station</p>
     <h1 class="page-h">How to use the playlist generator</h1>
     <p class="lede" style="margin-top:16px">The playlist generator builds hours of programming from your music library in one click. You tell it what pools of songs you have (categories) and how an hour should sound (a template), and it fills the playlist, keeps artists and songs apart, changes the sound for different times of day and drops in jingles, talk and time announcements on the clock.</p>
-    <nav class="toc" aria-label="On this page"><a href="#before">Before you start</a><a href="#categories">Categories</a><a href="#templates">Templates</a><a href="#dayparts">Times of day</a><a href="#inserts">Inserts</a><a href="#generate">Preview and generate</a><a href="#auto">Auto-playlist</a><a href="#schedule">On a schedule</a><a href="#tips">Tips</a></nav>
+    <nav class="toc" aria-label="On this page"><a href="#before">Before you start</a><a href="#categories">Categories</a><a href="#templates">Templates</a><a href="#dayparts">Times of day</a><a href="#generate">Preview and generate</a><a href="#auto">Auto-playlist</a><a href="#schedule">On a schedule</a><a href="#tips">Tips</a></nav>
   </section>
 
   <section class="block">
@@ -147,15 +147,12 @@ <h2 id="dayparts">3. Times of day</h2>
       <div class="rundown-table"><table><thead><tr><th>Time of day</th><th>Hours and days</th><th>Pattern</th></tr></thead><tbody><tr><td class="it">Breakfast</td><td>06:00–10:00, Mon–Fri</td><td>1 × Talk, 2 × Current</td></tr><tr><td class="it">Overnight</td><td>00:00–06:00, every day</td><td>3 × Gold, 1 × Station IDs</td></tr></tbody></table></div>
       <p>The clock follows the new tracks from where they will start on air, so a template that runs from 05:00 switches to the breakfast pattern at about 06:00.</p>
 
-      <h2 id="inserts">4. Inserts</h2>
-      <p>Inserts are things that go in on their own schedule instead of by position in the pattern, set up like <a href="/guides/advertisement-scheduler/">advert and jingle rules</a>. Press <b>➕ Add insert</b>, pick what to insert and how many, then when:</p>
-      <div class="rundown-table"><table><thead><tr><th>When</th><th>Example</th></tr></thead><tbody><tr><td class="k">after every N songs</td><td>1 × Station IDs after every 4 songs</td></tr><tr><td class="k">every N minutes</td><td>A jingle every 15 minutes. Tick <b>on the clock</b> to count from the top of the hour, so every 60 minutes means at :00.</td></tr><tr><td class="k">at set times</td><td>1 × Talk at 18:00 and 20:30</td></tr></tbody></table></div>
-      <p>Each insert can be limited to some hours (untick <b>all day</b>). An insert can come from a category, from the files of an advert or jingle rule, or be a <b>⏰ Time announcement</b>: <b>➕ Add time announcement</b> adds one at the top of every hour. <b>➕ Add jingles</b> is a shortcut that adds your first jingle rule every 15 minutes.</p>
-      <p>Timed inserts go in after the song that's playing when the time comes, so songs are never cut.</p>
+      <h3>Jingles, adverts and time announcements</h3>
+      <p>For jingles and IDs in a fixed spot, add them as a pattern step (step 4 in the example above). For anything on its own schedule, such as a jingle every 15 minutes, adverts at set times or after every few songs, use the <a href="/guides/advertisement-scheduler/">advertisement scheduler</a>: its rules fire while the generated playlist plays, so they aren't put in twice. For a time announcement at the top of every hour, use <b>➕ Hourly time announcement</b> in the <a href="/guides/event-scheduler/">event scheduler</a>.</p>
       <h3>Hour markers</h3>
       <p>Tick <b>Hour marker at the top of every hour</b> and the generator places an <a href="/#playlist">hour marker</a> where each new hour starts, so the station stays on the clock even if the songs run long or short.</p>
 
-      <h2 id="generate">5. Preview and generate</h2>
+      <h2 id="generate">4. Preview and generate</h2>
       <p><b>👁 Preview</b> shows the running order with the time each row starts, the number of tracks and the total length, without touching the playlist. Press <b>⟳ Again</b> for another mix, tick <b>after the playlist</b> to see it as an addition, and <b>✔ Put it in the playlist</b> when you like it. Or go straight to:</p>
       <ul>
         <li><b>▶ Generate (replace playlist)</b> clears the playlist and fills it with the template.</li>
@@ -175,7 +172,6 @@ <h2 id="tips">Tips</h2>
       <ul>
         <li>Within one generated playlist, every track in a category plays once before any of them repeats, so big categories stay fresh.</li>
         <li>If artist separation can't be met (a small category with few artists), the generator still picks a track rather than leaving a gap.</li>
-        <li>Timed inserts (jingles, IDs, adverts) don't count towards artist separation.</li>
         <li>Times of day let one template cover a whole day. For very different shows you can still make a template each and switch between them with the event scheduler.</li>
         <li>While connected to <a href="/server/">RadioMaster Server</a>, the library and folders are the server's, so a category folder is typed the way the server sees it, for example <code>/srv/music/current</code>.</li>
       </ul>
diff --git a/src/app.rs b/src/app.rs
index aab0fca..2c5977f 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -639,12 +639,10 @@ fn action_pick(action: ActionKind) -> Pick {
 }
 
 /// Where generator tracks come from: a category, or the files of an advert / jingle rule
-/// (stored as "rule:<id>"). `rules` = (id, name, adverts). `time` also offers a time announcement
-/// (for inserts).
-fn source_combo(ui: &mut egui::Ui, id: impl std::hash::Hash, cur: &mut String, cats: &[String], rules: &[(u64, String, bool)], time: bool) {
+/// (stored as "rule:<id>"). `rules` = (id, name, adverts).
+fn source_combo(ui: &mut egui::Ui, id: impl std::hash::Hash, cur: &mut String, cats: &[String], rules: &[(u64, String, bool)]) {
     let shown = match cur.strip_prefix("rule:").and_then(|s| s.parse::<u64>().ok()) {
         Some(rid) => rules.iter().find(|r| r.0 == rid).map(|r| format!("⚡ {}", r.1)).unwrap_or_else(|| tr("(deleted rule)").to_string()),
-        None if cur == crate::generator::TIME_SOURCE => format!("⏰ {}", tr("Time announcement")),
         None => cur.clone(),
     };
     egui::ComboBox::from_id_salt(id).selected_text(shown).width(170.0).show_ui(ui, |ui| {
@@ -660,10 +658,6 @@ fn source_combo(ui: &mut egui::Ui, id: impl std::hash::Hash, cur: &mut String, c
                 ui.selectable_value(cur, format!("rule:{rid}"), format!("⚡ {name}  ({tag})"));
             }
         }
-        if time {
-            ui.separator();
-            ui.selectable_value(cur, crate::generator::TIME_SOURCE.to_string(), format!("⏰ {}", tr("Time announcement")));
-        }
     });
 }
 
diff --git a/src/config.rs b/src/config.rs
index 9cb7cd9..e82e10f 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -539,43 +539,6 @@ impl Default for PatternItem {
     }
 }
 
-#[derive(Serialize, Deserialize, Clone)]
-#[serde(default)]
-pub struct Marker {
-    /// a category name, "rule:<id>" for the files of an advert / jingle rule, or
-    /// `generator::TIME_SOURCE` for a time announcement
-    pub category: String,
-    /// after every N songs, every N minutes, or at set times (like an advert / jingle rule)
-    pub trigger: Trigger,
-    pub every_songs: u32,
-    pub every_mins: u32,
-    /// every N minutes counted from the top of the hour (:00, :15…) instead of from the start
-    pub on_clock: bool,
-    /// (hour, minute) for `Trigger::Times`
-    pub times: Vec<(u32, u32)>,
-    /// how many to insert each time
-    pub count: u32,
-    /// only between these hours (from == to: all day)
-    pub from_hour: u32,
-    pub to_hour: u32,
-}
-impl Default for Marker {
-    fn default() -> Self {
-        Self {
-            category: "Music".into(),
-            // inserts made before 0.2.9 only had "every N minutes"
-            trigger: Trigger::Minutes,
-            every_songs: 4,
-            every_mins: 60,
-            on_clock: false,
-            times: vec![],
-            count: 1,
-            from_hour: 0,
-            to_hour: 0,
-        }
-    }
-}
-
 /// A different pattern for part of the day, e.g. talk and fewer songs on weekday mornings.
 #[derive(Serialize, Deserialize, Clone)]
 #[serde(default)]
@@ -620,7 +583,6 @@ pub struct Template {
     pub pattern: Vec<PatternItem>,
     /// patterns used instead of `pattern` at some times of day (the first that covers the time wins)
     pub dayparts: Vec<Daypart>,
-    pub markers: Vec<Marker>,
     pub artist_gap: u32,
     /// the same song doesn't come back within this many minutes (0 = whenever its pool runs out)
     pub song_gap_mins: u32,
@@ -636,7 +598,6 @@ impl Default for Template {
             until: (0, 0),
             pattern: vec![PatternItem::default()],
             dayparts: vec![],
-            markers: vec![],
             artist_gap: 5,
             song_gap_mins: 0,
             hour_markers: false,
@@ -1101,6 +1062,16 @@ mod rule_tests {
         assert!(c.rotations.is_empty() && c.ad_breaks.is_empty());
     }
 
+    #[test]
+    fn templates_saved_with_inserts_still_load() {
+        // generator inserts ("markers") were removed; old settings still load with everything else
+        let old = r#"{"templates":[{"name":"Day","minutes":90,"artist_gap":3,
+                      "markers":[{"category":"rule:1","trigger":"Minutes","every_mins":15,"count":1}]}]}"#;
+        let c: Config = serde_json::from_str(old).unwrap();
+        assert_eq!(c.templates.len(), 1);
+        assert_eq!((c.templates[0].name.as_str(), c.templates[0].minutes, c.templates[0].artist_gap), ("Day", 90, 3));
+    }
+
     #[test]
     fn cart_pads_keep_their_colour_and_old_pads_have_none() {
         let old: CartPad = serde_json::from_str(r#"{"label":"ID","path":"/j/id.mp3"}"#).unwrap();
diff --git a/src/generator.rs b/src/generator.rs
index da99330..116aae3 100644
--- a/src/generator.rs
+++ b/src/generator.rs
@@ -1,29 +1,13 @@
 //! Playlist generator: builds multi-hour programming from templates
-//! (category pattern + time-of-day patterns + inserts by songs / minutes / set times + artist and
-//! song separation), laid out along the clock from the time the new rows will start.
+//! (category pattern + time-of-day patterns + artist and song separation), laid out along the
+//! clock from the time the new rows will start.
 
-use crate::config::{hours_ok, Category, GenLength, Marker, Template, Trigger};
+use crate::config::{Category, GenLength, Template};
 use crate::library::Track;
-use chrono::{Duration, NaiveDateTime, NaiveTime, Timelike};
+use chrono::{Duration, NaiveDateTime, NaiveTime};
 use rand::seq::SliceRandom;
 use std::collections::{HashMap, VecDeque};
 
-/// Marker source that inserts a time announcement instead of tracks.
-pub const TIME_SOURCE: &str = "@time";
-/// Rough air time of a time announcement.
-pub const TIME_SECS: f32 = 4.0;
-
-/// One generated row.
-#[derive(Clone, Debug)]
-pub enum Gen {
-    /// a track from a pattern step (`insert` = false) or an insert
-    Track {
-        track: Track,
-        insert: bool,
-    },
-    TimeAnnounce,
-}
-
 struct Bag {
     idx: Vec<usize>,
     pos: usize,
@@ -95,23 +79,6 @@ fn next_clock(t: NaiveDateTime, (h, m): (u32, u32)) -> NaiveDateTime {
     }
 }
 
-/// When an insert by time goes off next after `t` (None: never, or it counts songs).
-fn next_due(m: &Marker, t: NaiveDateTime) -> Option<NaiveDateTime> {
-    match m.trigger {
-        Trigger::Songs => None,
-        Trigger::Times => m.times.iter().map(|&hm| next_clock(t, hm)).min(),
-        Trigger::Minutes => {
-            let n = m.every_mins.max(1) as i64;
-            if !m.on_clock {
-                return Some(t + Duration::minutes(n));
-            }
-            let midnight = t.date().and_time(NaiveTime::MIN);
-            let mins = (t - midnight).num_seconds() / 60;
-            Some(midnight + Duration::minutes((mins / n + 1) * n))
-        }
-    }
-}
-
 /// When a generated playlist starting at `start` should end.
 pub fn end_of(t: &Template, start: NaiveDateTime) -> NaiveDateTime {
     match t.length {
@@ -130,8 +97,8 @@ pub fn generate(
     preset: &HashMap<String, Vec<usize>>,
     start: NaiveDateTime,
     span: &dyn Fn(&Track) -> f32,
-) -> Vec<Gen> {
-    let mut out: Vec<Gen> = vec![];
+) -> Vec<Track> {
+    let mut out: Vec<Track> = vec![];
     if t.pattern.is_empty() && t.dayparts.iter().all(|d| d.pattern.is_empty()) {
         return out;
     }
@@ -156,8 +123,6 @@ pub fn generate(
     // (track, seconds after start) of songs inside the song gap
     let mut played: VecDeque<(usize, f64)> = VecDeque::new();
     let gap = t.song_gap_mins as f64 * 60.0;
-    let mut due: Vec<Option<NaiveDateTime>> = t.markers.iter().map(|m| next_due(m, start)).collect();
-    let mut songs: Vec<u32> = vec![0; t.markers.len()];
 
     // which pattern is in use (None = the main one) and the step it's on
     let mut part: Option<Option<usize>> = None;
@@ -201,50 +166,7 @@ pub fn generate(
             if gap > 0.0 {
                 played.push_back((i, since));
             }
-            out.push(Gen::Track { track: tr, insert: false });
-
-            // inserts that go off now
-            for (k, m) in t.markers.iter().enumerate() {
-                let fire = match m.trigger {
-                    Trigger::Songs => {
-                        songs[k] += 1;
-                        if songs[k] >= m.every_songs.max(1) {
-                            songs[k] = 0;
-                            Some(clock)
-                        } else {
-                            None
-                        }
-                    }
-                    _ => match due[k] {
-                        Some(at) if clock >= at => {
-                            // the next time after now (missed times aren't played twice)
-                            let mut next = next_due(m, at);
-                            while let Some(n) = next.filter(|n| *n <= clock) {
-                                next = next_due(m, n);
-                            }
-                            due[k] = next;
-                            Some(at)
-                        }
-                        _ => None,
-                    },
-                };
-                let Some(at) = fire else { continue };
-                if !hours_ok(m.from_hour, m.to_hour, at.hour()) {
-                    continue;
-                }
-                if m.category == TIME_SOURCE {
-                    clock += secs(TIME_SECS);
-                    out.push(Gen::TimeAnnounce);
-                    continue;
-                }
-                get_bag(&m.category, &mut bags);
-                for _ in 0..m.count.max(1) {
-                    if let Some(j) = bags.get_mut(&m.category).and_then(|b| b.next(lib, &VecDeque::new(), &VecDeque::new())) {
-                        clock += secs(span(&lib[j]));
-                        out.push(Gen::Track { track: lib[j].clone(), insert: true });
-                    }
-                }
-            }
+            out.push(tr);
             if clock >= end {
                 return out;
             }
@@ -264,7 +186,7 @@ pub fn generate(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::config::{Daypart, Marker, PatternItem};
+    use crate::config::{Daypart, PatternItem};
     use chrono::NaiveDate;
     use std::path::PathBuf;
 
@@ -311,50 +233,35 @@ mod tests {
         // a Monday
         NaiveDate::from_ymd_opt(2026, 10, 26).unwrap().and_hms_opt(h, m, 0).unwrap()
     }
-    fn run(t: &Template, start: NaiveDateTime) -> Vec<Gen> {
+    fn run(t: &Template, start: NaiveDateTime) -> Vec<Track> {
         generate(t, &cats(), &lib(), &HashMap::new(), start, &|t| t.duration)
     }
-    fn tracks(out: &[Gen]) -> Vec<&Track> {
-        out.iter()
-            .filter_map(|g| match g {
-                Gen::Track { track, .. } => Some(track),
-                Gen::TimeAnnounce => None,
-            })
-            .collect()
-    }
-    /// (clock time, row) for every generated row
-    fn timeline(out: &[Gen], start: NaiveDateTime) -> Vec<(NaiveDateTime, &Gen)> {
+    /// (clock time, track) for every generated row
+    fn timeline(out: &[Track], start: NaiveDateTime) -> Vec<(NaiveDateTime, &Track)> {
         let mut t = start;
         out.iter()
             .map(|g| {
                 let here = t;
-                let s = match g {
-                    Gen::Track { track, .. } => track.duration,
-                    Gen::TimeAnnounce => TIME_SECS,
-                };
-                t += Duration::milliseconds((s * 1000.0) as i64);
+                t += Duration::milliseconds((g.duration * 1000.0) as i64);
                 (here, g)
             })
             .collect()
     }
 
     #[test]
-    fn reaches_target_length_with_markers_and_artist_gap() {
+    fn reaches_target_length_with_artist_gap() {
         let t = Template {
             name: "t".into(),
             minutes: 60,
             pattern: vec![PatternItem { category: "Music".into(), count: 3 }],
-            markers: vec![Marker { category: "Jingles".into(), every_mins: 15, count: 1, ..Default::default() }],
             artist_gap: 4,
             ..Default::default()
         };
-        let out = run(&t, at(12, 0));
-        let all = tracks(&out);
+        let all = run(&t, at(12, 0));
         let total: f32 = all.iter().map(|t| t.duration).sum();
         assert!((3600.0..3600.0 + 400.0).contains(&total), "total {total}");
-        assert!(all.iter().any(|t| t.path.starts_with("/jingles")));
         // no artist repeats within the gap among music tracks
-        let music: Vec<&&Track> = all.iter().filter(|t| t.path.starts_with("/music")).collect();
+        let music: Vec<&Track> = all.iter().filter(|t| t.path.starts_with("/music")).collect();
         for w in music.windows(5) {
             let mut s = std::collections::HashSet::new();
             assert!(w.iter().all(|t| s.insert(t.artist.clone())), "artist repeated inside gap");
@@ -368,81 +275,19 @@ mod tests {
     }
 
     #[test]
-    fn jingle_rules_can_be_markers_and_steps() {
+    fn jingle_rules_can_be_steps() {
         let lib = lib();
         // "rule:1" = the five jingles (indexes 40..45)
         let preset: HashMap<String, Vec<usize>> = [("rule:1".to_string(), (40..45).collect())].into();
         let t = Template {
             minutes: 60,
             pattern: vec![PatternItem { category: "Music".into(), count: 2 }, PatternItem { category: "rule:1".into(), count: 1 }],
-            markers: vec![Marker { category: "rule:1".into(), every_mins: 30, count: 2, ..Default::default() }],
             ..Default::default()
         };
-        let out = generate(&t, &cats(), &lib, &preset, at(12, 0), &|t| t.duration);
-        let all = tracks(&out);
+        let all = generate(&t, &cats(), &lib, &preset, at(12, 0), &|t| t.duration);
         let jingles = all.iter().filter(|t| t.path.starts_with("/jingles")).count();
         let songs = all.len() - jingles;
-        assert!(jingles >= songs / 2 + 2, "a jingle after every 2 songs plus 2 every half hour ({jingles} for {songs} songs)");
-    }
-
-    #[test]
-    fn time_announcement_at_the_top_of_every_hour() {
-        let t = Template {
-            minutes: 180,
-            pattern: vec![PatternItem { category: "Music".into(), count: 1 }],
-            markers: vec![Marker { category: TIME_SOURCE.into(), every_mins: 60, on_clock: true, ..Default::default() }],
-            ..Default::default()
-        };
-        let start = at(12, 10);
-        let out = run(&t, start);
-        let times: Vec<NaiveDateTime> =
-            timeline(&out, start).into_iter().filter(|(_, g)| matches!(g, Gen::TimeAnnounce)).map(|(t, _)| t).collect();
-        assert_eq!(times.len(), 3, "13:00, 14:00 and 15:00");
-        for (k, t) in times.iter().enumerate() {
-            let top = at(13 + k as u32, 0);
-            // after the song that runs over the hour, so within one song length
-            assert!(*t >= top && *t < top + Duration::minutes(3) + Duration::seconds(1), "announcement at {t}");
-        }
-    }
-
-    #[test]
-    fn inserts_at_set_times_and_after_songs_with_hours() {
-        let t = Template {
-            minutes: 240,
-            pattern: vec![PatternItem { category: "Music".into(), count: 1 }],
-            markers: vec![
-                Marker { category: "Talk".into(), trigger: Trigger::Times, times: vec![(13, 30), (15, 0)], ..Default::default() },
-                // a jingle after every 3 songs, but only from 14:00 to 15:00
-                Marker {
-                    category: "Jingles".into(),
-                    trigger: Trigger::Songs,
-                    every_songs: 3,
-                    from_hour: 14,
-                    to_hour: 15,
-                    ..Default::default()
-                },
-            ],
-            ..Default::default()
-        };
-        let start = at(12, 0);
-        let out = run(&t, start);
-        let line = timeline(&out, start);
-        let talk: Vec<NaiveDateTime> = line
-            .iter()
-            .filter(|(_, g)| matches!(g, Gen::Track { track, .. } if track.path.starts_with("/talk")))
-            .map(|(t, _)| *t)
-            .collect();
-        assert_eq!(talk.len(), 2);
-        assert!(talk[0] >= at(13, 30) && talk[0] < at(13, 34));
-        assert!(talk[1] >= at(15, 0) && talk[1] < at(15, 4));
-        let jingles: Vec<NaiveDateTime> = line
-            .iter()
-            .filter(|(_, g)| matches!(g, Gen::Track { track, .. } if track.path.starts_with("/jingles")))
-            .map(|(t, _)| *t)
-            .collect();
-        assert!(jingles.len() >= 5, "about 6 in the hour ({})", jingles.len());
-        // fired from 14:00 (the song before it counted) and before 15:00 (plus one song)
-        assert!(jingles.iter().all(|t| *t >= at(14, 0) && *t < at(15, 4)), "{jingles:?}");
+        assert!(jingles + 1 >= songs / 2 && jingles <= songs / 2, "a jingle after every 2 songs ({jingles} for {songs} songs)");
     }
 
     #[test]
@@ -463,14 +308,9 @@ mod tests {
         let out = run(&t, start);
         let line = timeline(&out, start);
         let (last_t, last) = line.last().unwrap();
-        let end = *last_t
-            + Duration::seconds(match last {
-                Gen::Track { track, .. } => track.duration as i64,
-                _ => 4,
-            });
+        let end = *last_t + Duration::seconds(last.duration as i64);
         assert!(end >= at(8, 0) && end < at(8, 6), "ends at {end}");
-        for (t, g) in &line {
-            let Gen::Track { track, .. } = g else { continue };
+        for (t, track) in &line {
             if *t < at(7, 0) {
                 assert!(track.path.starts_with("/music"), "{t}: music before 7");
             } else {
@@ -491,13 +331,8 @@ mod tests {
         let start = at(12, 0);
         let out = run(&t, start);
         let line = timeline(&out, start);
-        let talk: Vec<(NaiveDateTime, &str)> = line
-            .iter()
-            .filter_map(|(t, g)| match g {
-                Gen::Track { track, .. } if track.path.starts_with("/talk") => Some((*t, track.title.as_str())),
-                _ => None,
-            })
-            .collect();
+        let talk: Vec<(NaiveDateTime, &str)> =
+            line.iter().filter(|(_, track)| track.path.starts_with("/talk")).map(|(t, track)| (*t, track.title.as_str())).collect();
         for (k, (t, title)) in talk.iter().enumerate() {
             for (t2, title2) in &talk[k + 1..] {
                 if title == title2 {
diff --git a/src/genui.rs b/src/genui.rs
index 6d3cbcf..950960b 100644
--- a/src/genui.rs
+++ b/src/genui.rs
@@ -1,13 +1,10 @@
-//! Playlist Generator: categories, templates (pattern, time-of-day patterns, inserts by songs /
-//! minutes / set times, length, separation) and a preview of the running order before it goes in.
+//! Playlist Generator: categories, templates (pattern, time-of-day patterns, length, separation) and a preview of the running order before it goes in.
 use super::adsui::section;
 use super::*;
-use crate::config::{Category, Daypart, GenLength, Marker, PatternItem, Template, Trigger};
+use crate::config::{Category, Daypart, GenLength, PatternItem, Template};
 
 #[derive(Default)]
 pub(super) struct GenUi {
-    /// time to add to an insert "at set times"
-    pub new_time: (u32, u32),
     pub preview: Option<GenPreview>,
     /// bring the preview into view on the next frame
     pub show_preview: bool,
@@ -22,20 +19,6 @@ pub(super) struct GenPreview {
     pub times: Vec<(chrono::DateTime<Local>, f32)>,
 }
 
-/// "all day" or from … to hours (from == to means all day).
-fn hours_edit(ui: &mut egui::Ui, from: &mut u32, to: &mut u32) {
-    let mut all_day = *from == *to;
-    if ui.checkbox(&mut all_day, tr("all day")).changed() {
-        (*from, *to) = if all_day { (0, 0) } else { (6, 22) };
-    }
-    if !all_day {
-        ui.label(tr("from"));
-        ui.add(egui::DragValue::new(from).range(0..=23).custom_formatter(|v, _| format!("{:02}:00", v as u32)));
-        ui.label(tr("to"));
-        ui.add(egui::DragValue::new(to).range(0..=23).custom_formatter(|v, _| format!("{:02}:00", v as u32)));
-    }
-}
-
 fn hhmm(ui: &mut egui::Ui, h: &mut u32, m: &mut u32) {
     ui.add(egui::DragValue::new(h).range(0..=23).custom_formatter(|v, _| format!("{:02}", v as u32)));
     ui.label(":");
@@ -55,7 +38,7 @@ fn pattern_edit(
         ui.horizontal(|ui| {
             ui.label(format!("{}.", k + 1));
             ui.add(egui::DragValue::new(&mut p.count).range(1..=20).suffix(" ×"));
-            source_combo(ui, ("pat", id, k), &mut p.category, cats, rules, false);
+            source_combo(ui, ("pat", id, k), &mut p.category, cats, rules);
             if ui.small_button("✖").on_hover_text(tr("Remove this step")).clicked() {
                 pdel = Some(k);
             }
@@ -74,7 +57,6 @@ impl App {
         let cat_names: Vec<String> = core.cfg.categories.iter().map(|c| c.name.clone()).collect();
         let tpl_names: Vec<String> = core.cfg.templates.iter().map(|t| t.name.clone()).collect();
         let rules: Vec<(u64, String, bool)> = core.cfg.ad_rules.iter().map(|r| (r.id, r.name.clone(), r.adverts)).collect();
-        let first_jingle = rules.iter().find(|r| !r.2).map(|r| format!("rule:{}", r.0));
         let mut gen: Option<(String, bool)> = None;
         let mut preview: Option<(String, bool)> = None;
         egui::ScrollArea::vertical().show(ui, |ui| {
@@ -87,7 +69,7 @@ impl App {
                 ui.add(egui::DragValue::new(&mut core.cfg.auto_min_mins).range(1..=600).suffix(" min left"));
             });
             ui.label(
-                RichText::new(tr("The template's times of day and timed inserts follow the clock from where the new tracks start."))
+                RichText::new(tr("The template's times of day follow the clock from where the new tracks start."))
                     .small()
                     .color(GRAY),
             );
@@ -257,82 +239,6 @@ impl App {
             }
             ui.add_space(8.0);
 
-            section(ui, "4", tr("Inserts"));
-            ui.label(
-                RichText::new(tr("Jingles, adverts, talk or a time announcement, like the advert / jingle rules: after a number of songs, every so often, or at set times. Timed ones go in after the song that's playing when the time comes."))
-                    .color(GRAY),
-            );
-            let mut mdel = None;
-            for (k, m) in t.markers.iter_mut().enumerate() {
-                egui::Frame::group(ui.style()).show(ui, |ui| {
-                    ui.set_width(ui.available_width());
-                    ui.horizontal_wrapped(|ui| {
-                        ui.label(tr("Insert"));
-                        if m.category != crate::generator::TIME_SOURCE {
-                            ui.add(egui::DragValue::new(&mut m.count).range(1..=10).suffix(" ×"));
-                        }
-                        source_combo(ui, ("mk", k), &mut m.category, &cat_names, &rules, true);
-                        if delete_button(ui, ("insert", self.tpl_sel, k), tr("this insert")) {
-                            mdel = Some(k);
-                        }
-                    });
-                    ui.horizontal_wrapped(|ui| {
-                        ui.radio_value(&mut m.trigger, Trigger::Songs, tr("after every"));
-                        ui.add_enabled(m.trigger == Trigger::Songs, egui::DragValue::new(&mut m.every_songs).range(1..=100).suffix(" songs"));
-                        ui.radio_value(&mut m.trigger, Trigger::Minutes, tr("every"));
-                        ui.add_enabled_ui(m.trigger == Trigger::Minutes, |ui| {
-                            ui.add(egui::DragValue::new(&mut m.every_mins).range(1..=1440).suffix(" min"));
-                            ui.checkbox(&mut m.on_clock, tr("on the clock"))
-                                .on_hover_text(tr("Every 60 minutes on the clock = at the top of each hour. Off = counted from the start of the playlist."));
-                        });
-                    });
-                    ui.horizontal_wrapped(|ui| {
-                        ui.radio_value(&mut m.trigger, Trigger::Times, tr("at"));
-                        ui.add_enabled_ui(m.trigger == Trigger::Times, |ui| {
-                            let mut tdel = None;
-                            for (j, (h, mi)) in m.times.iter().enumerate() {
-                                if ui.button(format!("{h:02}:{mi:02}  ✖")).on_hover_text(tr("Remove this time")).clicked() {
-                                    tdel = Some(j);
-                                }
-                            }
-                            if let Some(j) = tdel {
-                                m.times.remove(j);
-                            }
-                            let (h, mi) = &mut self.gen.new_time;
-                            hhmm(ui, h, mi);
-                            if ui.button(tr("➕ Add time")).clicked() && !m.times.contains(&(*h, *mi)) {
-                                m.times.push((*h, *mi));
-                                m.times.sort();
-                            }
-                        });
-                    });
-                    ui.horizontal_wrapped(|ui| {
-                        ui.label(tr("Hours"));
-                        hours_edit(ui, &mut m.from_hour, &mut m.to_hour);
-                    });
-                });
-            }
-            if let Some(k) = mdel {
-                t.markers.remove(k);
-            }
-            ui.horizontal_wrapped(|ui| {
-                if ui
-                    .add_enabled(first_jingle.is_some(), egui::Button::new(tr("➕ Add jingles")))
-                    .on_hover_text(tr("Uses the files of a jingle rule (Advertisement scheduler) every 15 minutes"))
-                    .on_disabled_hover_text(tr("Make a jingle rule in the Advertisement scheduler first, or add a Jingles category"))
-                    .clicked()
-                {
-                    t.markers.push(Marker { category: first_jingle.clone().unwrap_or_default(), every_mins: 15, ..Default::default() });
-                }
-                if ui.button(tr("➕ Add time announcement")).on_hover_text(tr("At the top of every hour")).clicked() {
-                    t.markers.push(Marker { category: crate::generator::TIME_SOURCE.into(), on_clock: true, ..Default::default() });
-                }
-                if ui.button(tr("➕ Add insert")).clicked() {
-                    t.markers.push(Marker { category: cat_names.first().cloned().unwrap_or_default(), ..Default::default() });
-                }
-            });
-            ui.add_space(8.0);
-
             ui.separator();
             ui.horizontal_wrapped(|ui| {
                 if ui.button(tr("👁 Preview")).on_hover_text(tr("See the running order first; nothing changes until you use it")).clicked() {
diff --git a/src/playout.rs b/src/playout.rs
index b93b5d2..7d417db 100644
--- a/src/playout.rs
+++ b/src/playout.rs
@@ -2810,11 +2810,11 @@ impl Playout {
             self.say(format!("Template '{name}' not found"));
             return None;
         };
-        // advert / jingle rules used as pattern steps or markers: their files join the pool
+        // advert / jingle rules used as pattern steps: their files join the pool
         let mut lib = self.library.clone();
         let mut preset: HashMap<String, Vec<usize>> = HashMap::new();
         let sources = tpl.pattern.iter().chain(tpl.dayparts.iter().flat_map(|d| d.pattern.iter())).map(|p| &p.category);
-        let sources: Vec<String> = sources.chain(tpl.markers.iter().map(|m| &m.category)).cloned().collect();
+        let sources: Vec<String> = sources.cloned().collect();
         for src in &sources {
             let Some(id) = src.strip_prefix("rule:").and_then(|s| s.parse::<u64>().ok()) else { continue };
             if preset.contains_key(src) {
@@ -2830,21 +2830,14 @@ impl Playout {
         let mut t = self.generate_start(append);
         let span = |tr: &Track| self.span_of(tr);
         let made = crate::generator::generate(&tpl, &self.cfg.categories, &lib, &preset, t.naive_local(), &span);
-        if !made.iter().any(|g| matches!(g, crate::generator::Gen::Track { insert: false, .. })) {
+        if made.is_empty() {
             self.say("Generator produced nothing — scan the library and check category filters");
             return None;
         }
         let mut rows = vec![];
-        for g in made {
-            let (row, span) = match g {
-                crate::generator::Gen::Track { track, .. } => {
-                    let span = self.span_of(&track);
-                    (PlEntry::file(track), span)
-                }
-                crate::generator::Gen::TimeAnnounce => {
-                    (PlEntry::special(ItemKind::TimeAnnounce, "", crate::generator::TIME_SECS), crate::generator::TIME_SECS)
-                }
-            };
+        for track in made {
+            let span = self.span_of(&track);
+            let row = PlEntry::file(track);
             if tpl.hour_markers {
                 use chrono::Timelike;
                 let after = t + CDur::milliseconds((span * 1000.0) as i64);
@@ -3508,7 +3501,7 @@ mod tests {
 
     #[test]
     fn generated_rows_follow_the_clock_and_go_in() {
-        use crate::config::{Category, Marker, PatternItem, Template};
+        use crate::config::{Category, PatternItem, Template};
         let mut p = playout();
         p.library = (0..30)
             .map(|i| Track {
@@ -3524,12 +3517,12 @@ mod tests {
             name: "Clock".into(),
             minutes: 130,
             pattern: vec![PatternItem { category: "Music".into(), count: 1 }],
-            markers: vec![Marker { category: crate::generator::TIME_SOURCE.into(), on_clock: true, every_mins: 60, ..Default::default() }],
+            hour_markers: true,
             ..Default::default()
         }];
         let rows = p.generated_rows("Clock", false).unwrap();
-        let ann = rows.iter().filter(|r| matches!(r.kind, ItemKind::TimeAnnounce)).count();
-        assert!((2..=3).contains(&ann), "one per top of the hour in 130 minutes ({ann})");
+        let marks = rows.iter().filter(|r| matches!(r.kind, ItemKind::HourMarker { .. })).count();
+        assert!((2..=3).contains(&marks), "one per top of the hour in 130 minutes ({marks})");
         assert!(p.playlist.is_empty(), "a preview changes nothing");
         p.use_generated(rows.clone(), false);
         assert_eq!(p.playlist.len(), rows.len());