diff --git a/Cargo.lock b/Cargo.lock
index 312b8df..68fb70c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8,6 +8,8 @@ version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3b7f7f85a7e5f68090000ed7622545829afd484d210358702ae4cb97dd0c320"
 dependencies = [
+ "enumn",
+ "serde",
  "uuid",
 ]
 
@@ -26,6 +28,7 @@ dependencies = [
  "cfg-if",
  "getrandom 0.3.4",
  "once_cell",
+ "serde",
  "version_check",
  "zerocopy",
 ]
@@ -606,6 +609,9 @@ name = "bitflags"
 version = "2.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
+dependencies = [
+ "serde_core",
+]
 
 [[package]]
 name = "bitstream-io"
@@ -1843,6 +1849,7 @@ checksum = "0656a7530b9e2841ee7a5f983965bdd9840c32f4012f759cfd44b912cced6b34"
 dependencies = [
  "bytemuck",
  "emath",
+ "serde",
 ]
 
 [[package]]
@@ -1871,6 +1878,8 @@ dependencies = [
  "pollster 1.0.1",
  "profiling",
  "raw-window-handle",
+ "ron",
+ "serde",
  "static_assertions",
  "wasm-bindgen",
  "web-sys",
@@ -1895,6 +1904,8 @@ dependencies = [
  "log",
  "nohash-hasher",
  "profiling",
+ "ron",
+ "serde",
  "smallvec",
  "unicode-segmentation",
  "web-sys",
@@ -1935,6 +1946,7 @@ dependencies = [
  "objc2-ui-kit 0.3.2",
  "profiling",
  "raw-window-handle",
+ "serde",
  "smithay-clipboard",
  "web-time",
  "winit",
@@ -1979,6 +1991,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52c8d4141cf0f60fb2f7aefaf352d3ffa5171ef0ab09731c64391801e95e48f1"
 dependencies = [
  "bytemuck",
+ "serde",
 ]
 
 [[package]]
@@ -2040,6 +2053,17 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "enumn"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f9ed6b3789237c8a0c1c505af1c7eb2c560df6186f01b098c3a1064ea532f38"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "epaint"
 version = "0.36.2"
@@ -2058,6 +2082,7 @@ dependencies = [
  "parking_lot",
  "profiling",
  "self_cell",
+ "serde",
  "skrifa",
  "smallvec",
  "unicode-general-category",
@@ -2226,6 +2251,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "835ae9d781464a79026cde387f9cbc650c9a4909d7cf7e658b127e3c35d2f35d"
 dependencies = [
  "bytemuck",
+ "serde",
 ]
 
 [[package]]
@@ -6228,6 +6254,20 @@ dependencies = [
  "portable-atomic-util",
 ]
 
+[[package]]
+name = "ron"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81116b9531d61eabc41aeb228e4b6b2435bcca3233b98cf3b3077d4e6e9debb3"
+dependencies = [
+ "bitflags 2.13.2",
+ "once_cell",
+ "serde",
+ "serde_derive",
+ "typeid",
+ "unicode-ident",
+]
+
 [[package]]
 name = "roxmltree"
 version = "0.21.1"
@@ -6861,6 +6901,9 @@ name = "smallvec"
 version = "1.16.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b3dc8af474f516a851ff4bd12db780f948b9250ad37211e4eec0bccea54e01b"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "smithay-client-toolkit"
@@ -7850,6 +7893,12 @@ dependencies = [
  "rustc-hash 2.1.3",
 ]
 
+[[package]]
+name = "typeid"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
+
 [[package]]
 name = "typenum"
 version = "1.20.1"
diff --git a/README.md b/README.md
index 3584705..a94fa40 100644
--- a/README.md
+++ b/README.md
@@ -30,8 +30,8 @@ cargo run --release -p moq-studio --features capture,openh264 -- \
   the first relay only. The stream's tracks claim their bitrate on the first
   relay's link alone, so only that link is probed toward the stream's rate;
   no encoder adapts to either estimate.
-- `capture` adds camera, display, window, microphone, and system-audio sources.
-  On Linux it links ALSA; add `pipewire` for PipeWire cameras. `openh264`
+- `capture` adds camera, display, window, microphone, and system-audio
+  sources, and listening to a mix. On Linux it links ALSA; add `pipewire` for PipeWire cameras. `openh264`
   is the software H.264 fallback for a machine without a hardware encoder.
 - `cef` adds browser sources, on Linux only for now. The build takes CEF from
   `CEF_PATH`, which the dev shell sets, or else downloads it, and the binary
@@ -98,7 +98,7 @@ Every panel is a tab you can drag, split, or stack.
 | Devices | List this machine's cameras, displays, windows, and audio inputs, and add one as a source. |
 | Guests | Invite a guest, show their join link as a QR code, see who joined, and take a guest out of every scene. |
 | Filters | Crop the selected source or item, add, order, and set its filters, set an item's blend mode, and copy or paste filters. |
-| Audio | Set each audio source's gain and mute, and watch its meter and the program's. |
+| Audio | Add, rename (double-click), and remove mixes, pick the one on program and the one to listen to and on which output, and set each audio source's gain, mute, delay, and the mixes it feeds, with a meter on every mix and source. |
 | Output | Start and stop recording, set the canvas size and frame rate, and see the broadcast path, whether the program is encoding, and the encoder's work. |
 | Health | See how the stream reaches viewers, relay by relay and track by track, and the cause of each problem. |
 | Replay | Replay the last moments of the program or a source in a replay source, slowed down if you like, or save them as a clip. |
@@ -151,12 +151,34 @@ broadcast through the first relay while that relay has a route to it, and
 through the failover otherwise, so a publisher restarted behind only the
 failover replaces the first relay's copy once that copy ends. It plays the
 best video and audio its catalog lists, switches when the catalog changes, and
-comes back on its own when the publisher restarts. Audio from every source is mixed into the program whether
-or not its scene is live; mute a source to leave it out.
+comes back on its own when the publisher restarts.
+
+### Audio mixes
+
+Audio from every source is mixed whether or not its scene is live. A
+collection has one or more **mixes**, each the sum of the sources it is fed:
+for example, a stream mix that leaves out music you may not broadcast, and a
+monitor mix for your headphones. A source feeds every mix, a new one included,
+until you untick that mix in its row of the Audio panel; mute a source to take
+it out of every mix. **On program** picks the mix the broadcast carries, and
+switching it, or editing a mix, never drops or repeats audio. A recording
+holds the mix on program. The mix on program cannot be removed.
+
+**Listen** plays a mix to an audio output, from the `capture` feature's
+build: the system default, or the one picked under **Listen on**, which the
+studio remembers for you rather than in the scene file. Use headphones: a
+microphone that hears the speakers feeds the mix back into itself.
+
+A source's **delay** holds it back in every mix, up to 2 s, so a microphone
+lines up with a camera that lags it.
+
+Each mix is advanced on the program clock, and each output reads its mix on
+its own, so an output that falls behind skips ahead in its own audio rather
+than holding up the mixes or another output.
 
 A browser source renders a web page, such as an overlay, alert box, or chat
 widget, at the canvas frame rate (CEF caps it at 60) over a transparent
-background, and its sound joins the program audio. Every page shares one
+background, and its sound joins the mixes. Every page shares one
 browser profile, kept in `$XDG_DATA_HOME/moq-studio/browser`
 (`~/.local/share/moq-studio/browser` by default) rather than beside the scene
 file, so cookies and logins, such as an alert service's, survive a reload and
@@ -334,8 +356,14 @@ html = '''
 <div class="third">Ada Lovelace</div>
 '''
 
+[mixes]
+names = ["Stream", "Headphones"]
+program = "Stream" # the mix the broadcast carries
+
 [audio.guest]
 gain = 0.5
+exclude = ["Headphones"] # feeds every other mix
+delay = "80ms"
 
 [sources.camera-faded]
 kind = "clone"
@@ -383,6 +411,11 @@ file, which no item places, but which grades what a `lut` filter names it in),
 and `replay`, where the Replay panel plays replays. The Devices panel fills in
 ids. `[[top]]` items make up the top layer.
 
+`[mixes]` names every mix, in the order the Audio panel lists them, and the
+one on `program`; without it, the collection has one mix, `Program`.
+`[audio.<source>]` sets a source's linear `gain`, `muted`, the mixes it is
+left out of (`exclude`), and its `delay`.
+
 `[video.<source>]` sets a source's `crop` and `filters`, wherever it is shown,
 and an item's `crop`, `filters`, and `blend` its own. A `crop` trims a fraction
 (0 to 1) of the picture off its `left`, `top`, `right`, and `bottom`, opposite
@@ -442,7 +475,7 @@ before sharing.
 ## Output
 
 The program publishes as one H.264 rendition at the canvas size and frame rate,
-with Opus stereo audio, under the `--broadcast` path. Timestamps come from the
+with the mix on program as Opus stereo audio, under the `--broadcast` path. Timestamps come from the
 studio's own clock, so a source that stalls repeats its last picture instead of
 holding up the stream.
 
@@ -586,8 +619,9 @@ The Health panel grades the stream every second on the thresholds moq's
 `hang::health` shares with the rest of the stack, and lists each problem
 with its cause in plain words: a relay is unreachable, the uplink is
 congested or losing packets, the relay is far away, the encoder is behind or
-stuck, a source stalled (a camera or broadcast the program draws, or an
-unmuted microphone or system audio), or viewers are late, stalling, or cannot
+stuck, a source stalled (a camera or broadcast the program draws, or a
+microphone or system audio the mix on program plays: unmuted and not left
+out of it), or viewers are late, stalling, or cannot
 decode a track. A relay lost while the other serves is
 degraded, since viewers have nothing left to fall back to; with none serving
 it is unhealthy. Below that it shows:
diff --git a/quest/m0/README.md b/quest/m0/README.md
index 24aca04..4eea230 100644
--- a/quest/m0/README.md
+++ b/quest/m0/README.md
@@ -100,7 +100,8 @@ repository.
 - [Multiple canvases](/quest/m0/multi-canvas.md) - landscape and portrait canvases composite at once from shared sources
 - [The join page is live](/quest/m0/join-page-live.md) - `join.studio.moq.dev` serves the join page `--join-page` defaults to
 - [Guest return feed](/quest/m0/guest-return.md) - guests see the program and hear a mix-minus
-- [Audio mixes](/quest/m0/mixes.md) - per-output mixes, meters, monitoring, and sync offsets
+- [A recording picks its mix](/quest/m0/record-mix.md) - a recording keeps what the stream's mix leaves out
+- [Clap-to-measure sync delay](/quest/m0/sync-clap.md) - a clap sets a microphone's delay against its camera
 - [Audio filters](/quest/m0/audio-filters.md) - per-source noise suppression, gate, compressor, limiter, and plugins, configured from the studio
 - [Browser sources on macOS and Windows](/quest/m0/browser-source.md) - the out-of-process CEF pages Linux has, with shared GPU textures on the other desktops
 - [Published independently](/quest/m0/publish-independently.md) - a source opts out of the program and publishes its own track for services that place it themselves
diff --git a/quest/m0/broadcast-sync.md b/quest/m0/broadcast-sync.md
index 5f74d9f..8c1646b 100644
--- a/quest/m0/broadcast-sync.md
+++ b/quest/m0/broadcast-sync.md
@@ -12,7 +12,8 @@ can leave audio and video apart.
 Decided 2026-10-26 (maintainer):
 
 - **Scope:** broadcast sources only. Local devices keep the manual
-  per-source offsets in [Audio mixes](/quest/m0/mixes.md).
+  per-source `delay`, which [Clap-to-measure](/quest/m0/sync-clap.md) sets
+  from a clap.
 - **Delay:** reuse `moq play`'s timing, the `--delay auto` target from
   moq-audio's jitter estimate (`rs/moq-audio/src/jitter.rs`,
   `doc/concept/audio-jitter.md`), rather than a second algorithm or a manual
diff --git a/quest/m0/guest-return.md b/quest/m0/guest-return.md
index 74088b2..c963c1e 100644
--- a/quest/m0/guest-return.md
+++ b/quest/m0/guest-return.md
@@ -10,7 +10,7 @@ The join page plays it.
 ## Plan
 
 Decided 2026-11-02 (maintainer): guests get a mix-minus, not the full program,
-so this waits on audio mixes; video and audio land together. Publish into the
+and video and audio land together. Publish into the
 room the studio already owns, under names the room's token scope allows, and
 keep it free of the studio's own credentials. A guest's token subscribes only
 to its own renewals (`.renew/<identity>/<generation>`), so it must also grant the feed's
@@ -19,7 +19,7 @@ with the guest count, so bound it by design (the guest roster is already
 bounded to guests the studio signed for). Raised on
 [#10](https://github.com/moq-dev/studio/pull/10).
 
-## Required
-
-- [Audio mixes](/quest/m0/mixes.md) - the per-output mixes a mix-minus is
-  built from
+Audio mixes landed in [#32](https://github.com/moq-dev/studio/pull/32): build
+each guest's feed with moq-audio's `bus::Mix::minus` from the mix on program
+(`Sources::mix`), taking the guest's own strip out, which costs one
+subtraction per block rather than a mix per guest.
diff --git a/quest/m0/mixes.md b/quest/m0/mixes.md
deleted file mode 100644
index 9737d14..0000000
--- a/quest/m0/mixes.md
+++ /dev/null
@@ -1,26 +0,0 @@
-# [M] Audio mixes
-
-## Goal
-
-The program bus in moq-audio feeds several mixes. For example, a stream mix
-excludes the creator's music, a recording mix keeps it, and a monitor mix
-plays to headphones. Each source routes to any subset of mixes, and each
-output or recording picks a mix. Every source and mix shows a level meter.
-Per-source sync offsets fix cameras that lag their microphones, and a clap
-in front of the camera, seen and heard, measures the offset instead of
-guessing it.
-Each guest hears a mix-minus: the program without their own voice.
-
-## Plan
-
-Decided 2026-11-02 (maintainer): routing, mix-minus, and sync offsets live in
-moq-audio as a multi-mix router rather than one `Bus` per mix in the studio:
-`bus::Mix`, which the program audio already is. The studio adds the routing
-UI, meters, the headphone monitor, clap-to-measure offsets, and a mix pick per
-output and recording.
-
-The mixer runs on the audio clock and never blocks on a slow output. An
-output that falls behind drops its own audio, not the bus's.
-
-Benchmark source count against mix count, including sparse routing. A mix
-must cost only what is routed into it, never a scan of every source.
diff --git a/quest/m0/record-mix.md b/quest/m0/record-mix.md
new file mode 100644
index 0000000..038cdf3
--- /dev/null
+++ b/quest/m0/record-mix.md
@@ -0,0 +1,31 @@
+# [S] A recording picks its mix
+
+## Goal
+
+A recording in `moq-studio` picks any of the collection's mixes, so it can
+keep what the stream leaves out, such as the creator's music, while the
+broadcast carries the mix on program. A recording on the same mix as the
+program records as it does today.
+
+## Plan
+
+Split from [Audio mixes](https://github.com/moq-dev/studio/pull/32), which
+landed the mixes, routing, meters, delay, listening, and the program's pick
+(`[mixes] program`).
+
+A recording reads the studio's broadcast the way a viewer does
+(`rs/moq-studio/src/record.rs`), so a mix other than the program's needs an
+Opus track of its own. Keep that track off the relay: a mix the creator left
+off the stream must not be fetchable from it, as source tracks stay local
+after [Live encode control](/quest/m0/encode-control.md). Encode it only while
+a recording reads it, and record the program's video beside it in one file.
+The pick lives in the scene file beside `[mixes] program`, and the Output
+panel shows it. Update `README.md`.
+
+## Required
+
+- [Live encode control](/quest/m0/encode-control.md) - the local broadcast a mix track stays off the relay in
+
+## Related
+
+- [Destinations](/quest/m0/destinations.md) - each destination picks a mix the same way
diff --git a/quest/m0/sync-clap.md b/quest/m0/sync-clap.md
new file mode 100644
index 0000000..915f631
--- /dev/null
+++ b/quest/m0/sync-clap.md
@@ -0,0 +1,28 @@
+# [S] Clap-to-measure sync delay
+
+## Goal
+
+A clap in front of a camera, seen and heard, measures how far a microphone
+leads that camera, and sets the microphone's `delay` to it, instead of the
+creator guessing the number.
+
+## Plan
+
+Split from [Audio mixes](https://github.com/moq-dev/studio/pull/32), which
+landed the per-source `delay` the measurement sets.
+
+Measure both onsets on the program clock: the clap's sound in the
+microphone's audio before it is delayed, and the frame where the hands meet in
+the camera's pictures. The difference, bounded by moq-audio's
+`bus::MAX_DELAY`, becomes the delay, as one undoable edit. A clap that is not
+found, or found in only one of the two, fails with the reason rather than
+setting a guess.
+
+The studio sees a source's audio only through its strip's level meter, read
+once a frame, which is too coarse to time a clap. Timing it needs the
+source's samples, or an onset, with their position on the bus clock, which is
+moq-audio work: land it there first and pin it.
+
+## Related
+
+- [Broadcast sources play in sync](/quest/m0/broadcast-sync.md) - broadcast sources align on the publisher's timestamps instead
diff --git a/rs/moq-scene/src/clip.rs b/rs/moq-scene/src/clip.rs
index 7abee57..3c6398d 100644
--- a/rs/moq-scene/src/clip.rs
+++ b/rs/moq-scene/src/clip.rs
@@ -1,13 +1,13 @@
 //! Items and filters copied as text, to paste into another scene or another
 //! collection.
 
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 use std::path::Path;
 
 use serde::{Deserialize, Serialize};
 
 use crate::Error;
-use crate::collection::{Audio, Collection, Filter, Item, Layer, Source, Video, validate_filters, versioned};
+use crate::collection::{Audio, Collection, Filter, Item, Layer, Mixes, Source, Video, validate_filters, versioned};
 use crate::edit::Draft;
 
 /// What a copy holds: items, or a filter chain.
@@ -77,7 +77,7 @@ impl Clip {
 			clip.sources.insert(name.clone(), source);
 			names.push(collection.capture(&name).to_string());
 			if let Some(audio) = collection.audio.get(&name) {
-				clip.audio.insert(name.clone(), *audio);
+				clip.audio.insert(name.clone(), audio.clone());
 			}
 			if let Some(video) = collection.video.get(&name) {
 				names.extend(video.filters.iter().filter_map(read));
@@ -99,16 +99,26 @@ impl Clip {
 		let clip = Self::deserialize(table).map_err(|err| Error::Format(err.to_string()))?;
 		match &clip {
 			// The rules a collection holding just the clip would break, such as
-			// an item showing a source the clip lacks.
-			Self::Items(items) => Collection {
-				sources: items.sources.clone(),
-				audio: items.audio.clone(),
-				video: items.video.clone(),
-				scenes: Vec::new(),
-				top: items.items.clone(),
-				..Collection::new()
+			// an item showing a source the clip lacks. It has whatever mixes the
+			// clip's sources are left out of, which pasting checks.
+			Self::Items(items) => {
+				let excluded = items.audio.values().flat_map(|audio| &audio.exclude);
+				let mut names: BTreeSet<String> = excluded.cloned().collect();
+				names.insert(Mixes::DEFAULT.into());
+				Collection {
+					sources: items.sources.clone(),
+					mixes: Mixes {
+						names: names.into_iter().collect(),
+						program: Mixes::DEFAULT.into(),
+					},
+					audio: items.audio.clone(),
+					video: items.video.clone(),
+					scenes: Vec::new(),
+					top: items.items.clone(),
+					..Collection::new()
+				}
+				.validate()?
 			}
-			.validate()?,
 			Self::Filters(filters) => validate_filters(&filters.filters, "the copied filters")?,
 		}
 		Ok(clip)
@@ -138,7 +148,8 @@ impl Draft {
 	/// one shown, so items pasted within a collection are linked to the ones
 	/// copied. A source whose name is taken by a different one is added under
 	/// a new name, which clones and filters naming it follow, and an added
-	/// source brings its audio and video settings. An image or LUT under `dir`
+	/// source brings its audio and video settings, left out of only the mixes
+	/// both collections have. An image or LUT under `dir`
 	/// is named relative to it, as the scene file would.
 	pub fn paste(&mut self, layer: &Layer, items: &Items, dir: &Path) -> Result<(), Error> {
 		let mut names = BTreeMap::new();
@@ -190,7 +201,11 @@ impl Draft {
 		};
 		for (name, renamed) in added {
 			if let Some(audio) = items.audio.get(name) {
-				self.set_audio(&renamed, Some(*audio))?;
+				// Left out only of the mixes this collection has too.
+				let mut audio = audio.clone();
+				let mixes = &self.collection().mixes.names;
+				audio.exclude.retain(|mix| mixes.contains(mix));
+				self.set_audio(&renamed, Some(audio))?;
 			}
 			if let Some(video) = items.video.get(name) {
 				let filters = rename(&video.filters);
@@ -297,6 +312,40 @@ mod tests {
 		assert_eq!(pasted.scenes[0].items, source.scenes[0].items);
 	}
 
+	/// A pasted source keeps its sound's settings, left out of only the mixes
+	/// the collection it lands in has.
+	#[test]
+	fn pastes_audio_into_the_mixes_there() {
+		let mut source = Collection::new();
+		source.mixes.names.push("Stream".into());
+		source.sources.insert(
+			"guest".into(),
+			Source::Broadcast {
+				path: "room/guest".into(),
+			},
+		);
+		let audio = crate::Audio {
+			gain: 0.5,
+			exclude: ["Program".to_string(), "Stream".to_string()].into(),
+			..Default::default()
+		};
+		source.audio.insert("guest".into(), audio.clone());
+		source.scenes[0]
+			.items
+			.push(Item::new("guest", Rect::fill(&source.canvas)));
+		source.validate().unwrap();
+		let text = Clip::items(&source, source.scenes[0].items.clone(), Path::new(DIR))
+			.to_toml()
+			.unwrap();
+
+		let pasted = paste(&Collection::new(), &Layer::Top, &text, DIR);
+		let expected = crate::Audio {
+			exclude: ["Program".to_string()].into(),
+			..audio
+		};
+		assert_eq!(pasted.audio["guest"], expected);
+	}
+
 	/// A relative image path names the same file wherever the clip is pasted,
 	/// and stays relative, and linked, within its own collection.
 	#[test]
diff --git a/rs/moq-scene/src/collection.rs b/rs/moq-scene/src/collection.rs
index b197919..9c74226 100644
--- a/rs/moq-scene/src/collection.rs
+++ b/rs/moq-scene/src/collection.rs
@@ -29,8 +29,11 @@ pub struct Collection {
 	/// so one camera can appear in many scenes while being opened once.
 	#[serde(default)]
 	pub sources: BTreeMap<String, Source>,
-	/// Gain and mute of each audio-carrying source, by source name. A source
-	/// without an entry plays at unity.
+	/// The audio mixes, and which one the program carries.
+	#[serde(default, skip_serializing_if = "Mixes::is_default")]
+	pub mixes: Mixes,
+	/// Gain, mute, routing, and sync delay of each audio-carrying source, by
+	/// source name. A source without an entry plays at unity in every mix.
 	#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
 	pub audio: BTreeMap<String, Audio>,
 	/// The filters on each picture-carrying source, by source name, applied
@@ -60,6 +63,7 @@ impl Collection {
 			canvas: Canvas::default(),
 			transition: Transition::default(),
 			sources: BTreeMap::new(),
+			mixes: Mixes::default(),
 			audio: BTreeMap::new(),
 			video: BTreeMap::new(),
 			scenes: vec![Scene::new("Scene")],
@@ -215,6 +219,7 @@ impl Collection {
 			self.validate_chain(&video.filters, &on)?;
 		}
 
+		self.mixes.validate()?;
 		for (name, audio) in &self.audio {
 			if !self.sources.contains_key(name) {
 				return Err(Error::Invalid(format!(
@@ -224,6 +229,18 @@ impl Collection {
 			if !audio.gain.is_finite() || audio.gain < 0.0 {
 				return Err(Error::Invalid(format!("`{name}` has gain {}", audio.gain)));
 			}
+			if let Some(mix) = audio.exclude.iter().find(|mix| !self.mixes.names.contains(mix)) {
+				return Err(Error::Invalid(format!(
+					"`{name}` is left out of `{mix}`, which is not a mix"
+				)));
+			}
+			if audio.delay > moq_audio::bus::MAX_DELAY {
+				return Err(Error::Invalid(format!(
+					"`{name}` is held back {:?}, past the longest, {:?}",
+					audio.delay,
+					moq_audio::bus::MAX_DELAY
+				)));
+			}
 		}
 
 		Ok(())
@@ -1108,15 +1125,72 @@ impl Source {
 	}
 }
 
-/// The gain and mute of one source in the program audio.
-#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+/// The audio mixes every source with sound feeds, and which one the program
+/// carries.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Mixes {
+	/// Each mix's unique name, in the order the studio lists them.
+	pub names: Vec<String>,
+	/// The mix the program broadcast carries.
+	pub program: String,
+}
+
+impl Mixes {
+	/// The one mix a new collection has, which the program carries.
+	pub const DEFAULT: &str = "Program";
+
+	fn is_default(&self) -> bool {
+		*self == Self::default()
+	}
+
+	fn validate(&self) -> Result<(), Error> {
+		let mut names = BTreeSet::new();
+		for name in &self.names {
+			if name.is_empty() {
+				return Err(Error::Invalid("a mix has an empty name".into()));
+			}
+			if !names.insert(name.as_str()) {
+				return Err(Error::Invalid(format!("two mixes are named `{name}`")));
+			}
+		}
+		if !names.contains(self.program.as_str()) {
+			return Err(Error::Invalid(format!(
+				"the program carries `{}`, which is not a mix",
+				self.program
+			)));
+		}
+		Ok(())
+	}
+}
+
+impl Default for Mixes {
+	fn default() -> Self {
+		Self {
+			names: vec![Self::DEFAULT.into()],
+			program: Self::DEFAULT.into(),
+		}
+	}
+}
+
+/// The gain, mute, routing, and sync delay of one source with sound.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct Audio {
 	/// Linear gain: 1.0 is unity.
 	pub gain: f32,
-	/// Whether the source is silenced, keeping its gain.
+	/// Whether the source is silenced in every mix, keeping its gain.
 	#[serde(default)]
 	pub muted: bool,
+	/// The mixes the source is left out of. It feeds every other one,
+	/// including a mix added later.
+	#[serde(default, skip_serializing_if = "BTreeSet::is_empty")]
+	pub exclude: BTreeSet<String>,
+	/// How long the source is held back in every mix, so a microphone lines up
+	/// with a camera that lags it. At most the bus's
+	/// [`MAX_DELAY`](moq_audio::bus::MAX_DELAY).
+	#[serde(default, with = "humantime_serde", skip_serializing_if = "Duration::is_zero")]
+	pub delay: Duration,
 }
 
 impl Default for Audio {
@@ -1124,6 +1198,8 @@ impl Default for Audio {
 		Self {
 			gain: 1.0,
 			muted: false,
+			exclude: BTreeSet::new(),
+			delay: Duration::ZERO,
 		}
 	}
 }
@@ -1200,7 +1276,19 @@ mod tests {
 				height: 800,
 			},
 		);
-		collection.audio.insert("mic".into(), Audio { gain: 0.5, muted: true });
+		collection.mixes = Mixes {
+			names: vec!["Stream".into(), "Recording".into()],
+			program: "Stream".into(),
+		};
+		collection.audio.insert(
+			"mic".into(),
+			Audio {
+				gain: 0.5,
+				muted: true,
+				exclude: ["Recording".to_string()].into(),
+				delay: Duration::from_millis(80),
+			},
+		);
 		collection.sources.insert(
 			"camera faded".into(),
 			Source::Clone {
@@ -1268,8 +1356,14 @@ kind = "camera"
 kind = "color"
 color = "#ff000080"
 
+[mixes]
+names = ["Stream", "Recording"]
+program = "Stream"
+
 [audio.cam2]
 gain = 2.0
+exclude = ["Stream"]
+delay = "120ms"
 
 [sources.cam2]
 kind = "broadcast"
@@ -1324,9 +1418,12 @@ rect = { x = 0, y = 680, width = 1280, height = 40 }
 			collection.audio["cam2"],
 			Audio {
 				gain: 2.0,
-				muted: false
+				muted: false,
+				exclude: ["Stream".to_string()].into(),
+				delay: Duration::from_millis(120),
 			}
 		);
+		assert_eq!(collection.mixes.program, "Stream");
 		let main = collection.scene("Main").unwrap();
 		assert!(main.items[0].visible);
 		assert!(!main.items[1].visible);
@@ -1394,6 +1491,32 @@ rect = { x = 0, y = 680, width = 1280, height = 40 }
 		assert!(matches!(collection.validate(), Err(Error::Invalid(_))));
 	}
 
+	/// The program carries one of the mixes, each named once, and a source is
+	/// left out of mixes that exist, held back no longer than the bus can.
+	#[test]
+	fn refuses_a_mix_that_does_not_add_up() {
+		let refused = |edit: fn(&mut Collection)| {
+			let mut collection = example();
+			edit(&mut collection);
+			matches!(collection.validate(), Err(Error::Invalid(_)))
+		};
+		assert!(refused(|collection| collection.mixes.program = "Monitor".into()));
+		assert!(refused(|collection| collection.mixes.names.push("Stream".into())));
+		assert!(refused(|collection| collection.mixes.names.push(String::new())));
+		assert!(refused(|collection| {
+			let mic = collection.audio.get_mut("mic").unwrap();
+			mic.exclude.insert("Monitor".into());
+		}));
+		assert!(refused(|collection| {
+			let mic = collection.audio.get_mut("mic").unwrap();
+			mic.delay = moq_audio::bus::MAX_DELAY + Duration::from_millis(1);
+		}));
+		assert!(!refused(|collection| {
+			let mic = collection.audio.get_mut("mic").unwrap();
+			mic.delay = moq_audio::bus::MAX_DELAY;
+		}));
+	}
+
 	/// A clone shows another source's capture, so it must name one with a
 	/// picture that is not itself a clone, and only a picture is filtered.
 	#[test]
diff --git a/rs/moq-scene/src/edit.rs b/rs/moq-scene/src/edit.rs
index e7db3a4..b9ab777 100644
--- a/rs/moq-scene/src/edit.rs
+++ b/rs/moq-scene/src/edit.rs
@@ -14,7 +14,7 @@ use std::collections::{BTreeMap, VecDeque};
 use serde::{Deserialize, Serialize};
 
 use crate::Error;
-use crate::collection::{Audio, Canvas, Collection, Filter, Item, Layer, Scene, Source, Transition, Video};
+use crate::collection::{Audio, Canvas, Collection, Filter, Item, Layer, Mixes, Scene, Source, Transition, Video};
 
 /// One part of a collection, before and after an edit.
 ///
@@ -70,6 +70,8 @@ pub enum Change {
 	Transition { before: Transition, after: Transition },
 	/// [`Collection::canvas`].
 	Canvas { before: Canvas, after: Canvas },
+	/// [`Collection::mixes`].
+	Mixes { before: Mixes, after: Mixes },
 }
 
 impl Change {
@@ -115,6 +117,10 @@ impl Change {
 				before: after,
 				after: before,
 			},
+			Self::Mixes { before, after } => Self::Mixes {
+				before: after,
+				after: before,
+			},
 		}
 	}
 
@@ -122,7 +128,11 @@ impl Change {
 	fn entry(&self) -> Option<&str> {
 		match self {
 			Self::Source { name, .. } | Self::Audio { name, .. } | Self::Video { name, .. } => Some(name),
-			Self::Scene { .. } | Self::Item { .. } | Self::Transition { .. } | Self::Canvas { .. } => None,
+			Self::Scene { .. }
+			| Self::Item { .. }
+			| Self::Transition { .. }
+			| Self::Canvas { .. }
+			| Self::Mixes { .. } => None,
 		}
 	}
 
@@ -136,6 +146,7 @@ impl Change {
 			Self::Item { before, after, .. } => before == after,
 			Self::Transition { before, after } => before == after,
 			Self::Canvas { before, after } => before == after,
+			Self::Mixes { before, after } => before == after,
 		}
 	}
 
@@ -164,7 +175,7 @@ impl Change {
 			) if name == *n && after == *b => Self::Audio {
 				name,
 				before,
-				after: *a,
+				after: a.clone(),
 			},
 			(
 				Self::Video { name, before, after },
@@ -221,6 +232,10 @@ impl Change {
 			(Self::Canvas { before, after }, Self::Canvas { before: b, after: a }) if after == *b => {
 				Self::Canvas { before, after: *a }
 			}
+			(Self::Mixes { before, after }, Self::Mixes { before: b, after: a }) if after == *b => Self::Mixes {
+				before,
+				after: a.clone(),
+			},
 			_ => return None,
 		};
 		Some(merged)
@@ -261,6 +276,13 @@ impl Change {
 				collection.canvas = *after;
 				Ok(())
 			}
+			Self::Mixes { before, after } => {
+				if collection.mixes != *before {
+					return Err(conflict("the mixes changed".into()));
+				}
+				collection.mixes = after.clone();
+				Ok(())
+			}
 		}
 	}
 }
@@ -427,9 +449,10 @@ impl Draft {
 		})
 	}
 
-	/// Set or clear the gain and mute of the source called `name`.
+	/// Set or clear the gain, mute, routing, and delay of the source called
+	/// `name`.
 	pub fn set_audio(&mut self, name: &str, audio: Option<Audio>) -> Result<(), Error> {
-		let before = self.collection.audio.get(name).copied();
+		let before = self.collection.audio.get(name).cloned();
 		self.change(Change::Audio {
 			name: name.to_string(),
 			before,
@@ -624,6 +647,59 @@ impl Draft {
 		self.change(Change::Canvas { before, after: canvas })
 	}
 
+	/// Set the mixes and which one the program carries, and nothing else: see
+	/// [`rename_mix`](Self::rename_mix) and [`remove_mix`](Self::remove_mix) for
+	/// what refers to a mix.
+	pub fn set_mixes(&mut self, mixes: Mixes) -> Result<(), Error> {
+		let before = self.collection.mixes.clone();
+		self.change(Change::Mixes { before, after: mixes })
+	}
+
+	/// Rename the mix `from` to `to`, keeping its place, its routing, and
+	/// whether the program carries it.
+	pub fn rename_mix(&mut self, from: &str, to: &str) -> Result<(), Error> {
+		self.retarget_mix(from, Some(to))
+	}
+
+	/// Remove the mix `name`, and every source's exclusion from it. The mix the
+	/// program carries cannot be removed.
+	pub fn remove_mix(&mut self, name: &str) -> Result<(), Error> {
+		self.retarget_mix(name, None)
+	}
+
+	/// Rename the mix `from` to `to`, or remove it with `None`, and every
+	/// reference to it.
+	fn retarget_mix(&mut self, from: &str, to: Option<&str>) -> Result<(), Error> {
+		let mut mixes = self.collection.mixes.clone();
+		let index = mixes.names.iter().position(|name| name == from);
+		let index = index.ok_or_else(|| conflict(format!("there is no mix `{from}`")))?;
+		match to {
+			Some(to) => mixes.names[index] = to.to_string(),
+			None => {
+				mixes.names.remove(index);
+			}
+		}
+		if mixes.program == from {
+			mixes.program = to.unwrap_or_default().to_string();
+		}
+		let routed: Vec<(String, Audio)> = self
+			.collection
+			.audio
+			.iter()
+			.filter(|(_, audio)| audio.exclude.contains(from))
+			.map(|(name, audio)| (name.clone(), audio.clone()))
+			.collect();
+		self.set_mixes(mixes)?;
+		for (name, mut audio) in routed {
+			audio.exclude.remove(from);
+			if let Some(to) = to {
+				audio.exclude.insert(to.to_string());
+			}
+			self.set_audio(&name, Some(audio))?;
+		}
+		Ok(())
+	}
+
 	/// The edit, once the collection it leaves is valid. Changes that ended up
 	/// replacing something with itself are left out.
 	pub fn finish(mut self) -> Result<Edit, Error> {
@@ -1192,6 +1268,61 @@ mod tests {
 		assert!(matches!(draft.finish(), Err(Error::Invalid(_))));
 	}
 
+	/// A renamed mix keeps its place, the program's pick, and every source left
+	/// out of it; a removed one takes those exclusions with it and undoes
+	/// whole; and the mix the program carries stays.
+	#[test]
+	fn a_mix_renames_and_removes_with_its_routing() {
+		let mut collection = collection();
+		collection.sources.insert(
+			"guest".into(),
+			Source::Broadcast {
+				path: "room/guest".into(),
+			},
+		);
+		collection.mixes = Mixes {
+			names: vec!["Program".into(), "Stream".into()],
+			program: "Stream".into(),
+		};
+		let left_out = Audio {
+			exclude: ["Stream".to_string()].into(),
+			..Audio::default()
+		};
+		collection.audio.insert("guest".into(), left_out);
+		collection.validate().unwrap();
+		let start = collection.clone();
+		let mut history = History::new();
+
+		let mut draft = collection.draft("Rename mix");
+		draft.rename_mix("Stream", "Live").unwrap();
+		commit(&mut collection, &mut history, draft, None);
+		assert_eq!(collection.mixes.names, ["Program", "Live"]);
+		assert_eq!(collection.mixes.program, "Live");
+		assert_eq!(collection.audio["guest"].exclude, ["Live".to_string()].into());
+
+		let mut draft = collection.draft("Remove mix");
+		draft.remove_mix("Live").unwrap();
+		assert!(
+			matches!(draft.finish(), Err(Error::Invalid(_))),
+			"the program carries it"
+		);
+
+		let mut draft = collection.draft("Pick mix");
+		let mixes = Mixes {
+			program: "Program".into(),
+			..collection.mixes.clone()
+		};
+		draft.set_mixes(mixes).unwrap();
+		draft.remove_mix("Live").unwrap();
+		commit(&mut collection, &mut history, draft, None);
+		assert_eq!(collection.mixes, Mixes::default());
+		assert!(collection.audio["guest"].exclude.is_empty());
+
+		history.undo(&mut collection).unwrap();
+		history.undo(&mut collection).unwrap();
+		assert_eq!(collection, start);
+	}
+
 	#[test]
 	fn holds_at_most_the_limit() {
 		let mut collection = collection();
diff --git a/rs/moq-scene/src/lib.rs b/rs/moq-scene/src/lib.rs
index 5155270..4cbd969 100644
--- a/rs/moq-scene/src/lib.rs
+++ b/rs/moq-scene/src/lib.rs
@@ -42,7 +42,7 @@ pub mod source;
 
 pub use clip::Clip;
 pub use collection::{
-	Audio, Blend, Canvas, Collection, Crop, Direction, Filter, Item, Layer, MaskMode, Rect, Rgba, Scene, Source,
+	Audio, Blend, Canvas, Collection, Crop, Direction, Filter, Item, Layer, MaskMode, Mixes, Rect, Rgba, Scene, Source,
 	Transition, Video,
 };
 pub use compositor::{Compositor, FORMAT};
diff --git a/rs/moq-scene/src/source.rs b/rs/moq-scene/src/source.rs
index 2264931..9466a7a 100644
--- a/rs/moq-scene/src/source.rs
+++ b/rs/moq-scene/src/source.rs
@@ -133,10 +133,9 @@ pub enum Status {
 /// What every source shares.
 #[derive(Clone)]
 pub struct Context {
-	/// Where microphones, system audio, and broadcasts feed their sound.
+	/// Where microphones, system audio, and broadcasts feed their sound, and
+	/// where the collection's mixes are made.
 	pub bus: Bus,
-	/// The program audio: every running source with sound is routed into it.
-	pub program: Mix,
 	/// Where broadcast sources are announced: the studio's relay connection.
 	pub origin: moq_net::origin::Consumer,
 	/// What a relative image or LUT path is relative to: the scene file's directory.
@@ -150,18 +149,20 @@ pub struct Context {
 	pub publish: Option<Publish>,
 }
 
-/// The running sources of a collection.
+/// The running sources of a collection, and its mixes.
 pub struct Sources {
 	context: Context,
 	feeds: BTreeMap<String, Feed>,
+	mixes: BTreeMap<String, Mix>,
 }
 
 impl Sources {
-	/// No sources running yet; [`sync`](Self::sync) starts them.
+	/// No sources or mixes yet; [`sync`](Self::sync) starts them.
 	pub fn new(context: Context) -> Self {
 		Self {
 			context,
 			feeds: BTreeMap::new(),
+			mixes: BTreeMap::new(),
 		}
 	}
 
@@ -170,17 +171,32 @@ impl Sources {
 		&self.context
 	}
 
-	/// Run exactly the sources `collection` has: start new and edited ones and
-	/// stop removed and edited ones. A clone shares the feed of the source it
-	/// clones rather than opening one. Returns a driver for each source started,
-	/// which does nothing until run.
+	/// Run exactly the sources and mixes `collection` has: start new and edited
+	/// sources and stop removed and edited ones. A clone shares the feed of the
+	/// source it clones rather than opening one. Returns a driver for each
+	/// source started, which does nothing until run.
 	///
-	/// Also applies the collection's gain and mute to every audio strip, and its
-	/// frame rate to every web page, which never restarts a source. Panics on a
-	/// gain [`Collection::validate`] refuses.
+	/// Also applies the collection's gain, mute, delay, and routing to every
+	/// audio strip, and its frame rate to every web page, which never restarts
+	/// a source. A removed or edited source leaves every mix at once, so its
+	/// replacement never plays over it. Panics on a gain or delay
+	/// [`Collection::validate`] refuses.
 	pub fn sync(&mut self, collection: &Collection) -> Vec<Driver> {
-		self.feeds
-			.retain(|name, feed| collection.sources.get(name) == Some(&feed.source));
+		let mixes = &self.mixes;
+		self.feeds.retain(|name, feed| {
+			let keep = collection.sources.get(name) == Some(&feed.source);
+			if !keep {
+				leave(mixes, feed);
+			}
+			keep
+		});
+		// A mix ends once its last handle drops, which may be a reader's.
+		self.mixes.retain(|name, _| collection.mixes.names.contains(name));
+		for name in &collection.mixes.names {
+			if !self.mixes.contains_key(name) {
+				self.mixes.insert(name.clone(), self.context.bus.mix());
+			}
+		}
 
 		let mut drivers = Vec::new();
 		for (name, source) in collection.sources.iter().filter(|(_, source)| source.opens()) {
@@ -195,18 +211,33 @@ impl Sources {
 			}
 
 			if let Some(strip) = self.feeds[name].strip() {
-				let audio = collection.audio.get(name).copied().unwrap_or_default();
+				let audio = collection.audio.get(name).cloned().unwrap_or_default();
 				strip.set_gain(audio.gain);
 				strip.set_muted(audio.muted);
+				strip.set_delay(audio.delay);
+				for (mix_name, mix) in &self.mixes {
+					let routed = !audio.exclude.contains(mix_name);
+					if mix.routes(strip) == routed {
+						continue;
+					}
+					if routed {
+						mix.route(strip);
+					} else {
+						mix.unroute(strip);
+					}
+				}
 			}
 		}
 		drivers
 	}
 
 	/// Stop the source called `name`, so the next [`sync`](Self::sync) starts
-	/// it again, as an edit would, such as to reload a web page.
+	/// it again, as an edit would, such as to reload a web page. It leaves
+	/// every mix at once, as an edited source does.
 	pub fn restart(&mut self, name: &str) {
-		self.feeds.remove(name);
+		if let Some(feed) = self.feeds.remove(name) {
+			leave(&self.mixes, &feed);
+		}
 	}
 
 	/// The running source called `name`.
@@ -214,12 +245,36 @@ impl Sources {
 		self.feeds.get(name)
 	}
 
+	/// The mix called `name`, as the collection last synced had it.
+	pub fn mix(&self, name: &str) -> Option<&Mix> {
+		self.mixes.get(name)
+	}
+
+	/// Whether the mix called `mix` plays the source called `name`: it has
+	/// sound, is not muted, and is routed into that mix.
+	pub fn plays(&self, mix: &str, name: &str) -> bool {
+		let strip = self.feeds.get(name).and_then(Feed::strip);
+		let mix = self.mixes.get(mix);
+		strip
+			.zip(mix)
+			.is_some_and(|(strip, mix)| !strip.muted() && mix.routes(strip))
+	}
+
 	/// Every running source, by name.
 	pub fn iter(&self) -> impl Iterator<Item = (&str, &Feed)> {
 		self.feeds.iter().map(|(name, feed)| (name.as_str(), feed))
 	}
 }
 
+/// Take a stopping `feed` out of every one of `mixes`, so it leaves nothing
+/// behind in them, nor plays over a replacement.
+fn leave(mixes: &BTreeMap<String, Mix>, feed: &Feed) {
+	let Some(strip) = &feed.strip else { return };
+	for mix in mixes.values() {
+		mix.unroute(strip);
+	}
+}
+
 /// One running source. Dropping it stops its [`Driver`].
 pub struct Feed {
 	source: Source,
@@ -314,7 +369,7 @@ impl Feed {
 		(since >= STALL).then(|| stall(since))
 	}
 
-	/// The source's gain, mute, and meter in the program audio, if it has sound.
+	/// The source's gain, mute, delay, and meter in every mix, if it has sound.
 	pub fn strip(&self) -> Option<&Strip> {
 		self.strip.as_ref()
 	}
@@ -359,16 +414,6 @@ struct Track {
 	status: kio::Producer<Status>,
 }
 
-/// Takes the source out of the program, which [`open`] routed it into, so a
-/// removed or edited source leaves nothing behind in the mix.
-impl Drop for Driver {
-	fn drop(&mut self) {
-		if let Some(strip) = &self.strip {
-			self.context.program.unroute(strip);
-		}
-	}
-}
-
 impl Driver {
 	/// The source's name in the collection.
 	pub fn name(&self) -> &str {
@@ -967,9 +1012,6 @@ fn open(name: &str, source: &Source, context: &Context) -> (Feed, Driver) {
 	let picture = Mailbox::default();
 	let delivered = Delivered::default();
 	let strip = source.has_audio().then(Strip::default);
-	if let Some(strip) = &strip {
-		context.program.route(strip);
-	}
 	let status = kio::Producer::new(Status::Starting);
 	let page = matches!(source, Source::Browser { .. }).then(Page::default);
 	// Claimed here, in the order sources open, so an edited source's
@@ -1097,7 +1139,6 @@ pub(crate) mod test {
 		tokio::task::spawn_local(moq_net::time::run(driver));
 		let (bus, _) = Bus::new(Default::default()).unwrap();
 		let context = Context {
-			program: bus.mix(),
 			bus,
 			origin: origin.consume(),
 			dir: dir.to_path_buf(),
@@ -1287,9 +1328,61 @@ mod tests {
 		.await;
 	}
 
+	/// A mix plays a source with sound that is routed into it and not muted, so
+	/// one left out of the program's mix is heard only in the others.
+	#[tokio::test]
+	async fn a_mix_plays_only_what_is_routed_into_it() {
+		local(async {
+			let dir = tempfile::tempdir().unwrap();
+			let (context, _origin) = context(dir.path());
+			let mut sources = Sources::new(context);
+			let mut collection = collection();
+			collection.mixes.names.push("Headphones".into());
+			let program = crate::Mixes::DEFAULT;
+			let drivers = sources.sync(&collection);
+			start(&sources, drivers).await;
+			assert!(sources.plays(program, "guest"));
+			assert!(sources.plays("Headphones", "guest"));
+			assert!(!sources.plays(program, "red"), "a color is silent");
+			assert!(!sources.plays(program, "nobody"));
+			assert!(!sources.plays("Nothing", "guest"));
+
+			// A restart, such as a page's reload, leaves every mix at once, and
+			// the source comes back in under its new strip.
+			let before = sources.get("guest").unwrap().strip().unwrap().clone();
+			sources.restart("guest");
+			for mix in [program, "Headphones"] {
+				assert!(!sources.mix(mix).unwrap().routes(&before), "{mix} keeps the old strip");
+			}
+			let drivers = sources.sync(&collection);
+			start(&sources, drivers).await;
+			assert!(sources.plays(program, "guest"));
+
+			let left_out = Audio {
+				exclude: [program.to_string()].into(),
+				..Audio::default()
+			};
+			collection.audio.insert("guest".into(), left_out);
+			assert!(sources.sync(&collection).is_empty());
+			assert!(!sources.plays(program, "guest"), "left out of the program");
+			assert!(sources.plays("Headphones", "guest"));
+
+			let muted = Audio {
+				muted: true,
+				..Audio::default()
+			};
+			collection.audio.insert("guest".into(), muted);
+			assert!(sources.sync(&collection).is_empty());
+			assert!(!sources.plays(program, "guest"), "muted");
+			assert!(!sources.plays("Headphones", "guest"), "muted everywhere");
+		})
+		.await;
+	}
+
 	/// Editing a source restarts it, removing one stops it, and an untouched one
-	/// keeps running. Gain changes reach the strip without restarting anything,
-	/// and a source plays in the program until it is removed.
+	/// keeps running. Gain, delay, and routing changes reach the strip without
+	/// restarting anything, and a source plays in every mix it is not left out
+	/// of until it is removed.
 	#[tokio::test]
 	async fn sync_restarts_only_what_changed() {
 		local(async {
@@ -1300,19 +1393,34 @@ mod tests {
 			let drivers = sources.sync(&collection);
 			start(&sources, drivers).await;
 			let guest = sources.get("guest").unwrap().strip().unwrap().clone();
-			let program = sources.context().program.clone();
+			let program = sources.mix(crate::Mixes::DEFAULT).unwrap().clone();
 			assert!(program.routes(&guest));
 
+			collection.mixes.names.push("Stream".into());
 			collection.audio.insert(
 				"guest".into(),
 				Audio {
 					gain: 0.25,
 					muted: true,
+					exclude: ["Stream".to_string()].into(),
+					delay: Duration::from_millis(120),
 				},
 			);
 			assert!(sources.sync(&collection).is_empty());
 			assert_eq!(guest.gain(), 0.25);
 			assert!(guest.muted());
+			assert_eq!(guest.delay(), Duration::from_millis(120));
+			let stream = sources.mix("Stream").unwrap().clone();
+			assert!(program.routes(&guest));
+			assert!(!stream.routes(&guest), "left out of the new mix");
+
+			collection.audio.get_mut("guest").unwrap().exclude.clear();
+			assert!(sources.sync(&collection).is_empty());
+			assert!(stream.routes(&guest), "put back in");
+
+			collection.mixes.names.retain(|name| name != "Stream");
+			assert!(sources.sync(&collection).is_empty());
+			assert!(sources.mix("Stream").is_none());
 
 			collection.sources.insert(
 				"red".into(),
@@ -1334,13 +1442,7 @@ mod tests {
 
 			collection.sources.remove("guest");
 			assert!(sources.sync(&collection).is_empty());
-			for _ in 0..1000 {
-				if !program.routes(&guest) {
-					return;
-				}
-				tokio::task::yield_now().await;
-			}
-			panic!("a removed source stays in the program");
+			assert!(!program.routes(&guest), "a removed source leaves at once");
 		})
 		.await;
 	}
diff --git a/rs/moq-studio/Cargo.toml b/rs/moq-studio/Cargo.toml
index 02bc7da..a4c8ebe 100644
--- a/rs/moq-studio/Cargo.toml
+++ b/rs/moq-studio/Cargo.toml
@@ -18,10 +18,11 @@ categories = ["multimedia", "multimedia::video", "gui"]
 default = ["quic", "websocket", "nvidia"]
 quic = ["moq-tokio/quic"]
 websocket = ["moq-tokio/websocket"]
-# Camera, display, window, microphone, and system-audio sources. Off by default
-# like moq-cli's `capture`: on Linux the microphone links libasound at build
-# time. Enable with `cargo run -p moq-studio --features capture,openh264`.
-capture = ["moq-scene/capture"]
+# Camera, display, window, microphone, and system-audio sources, and playing a
+# mix to the speakers. Off by default like moq-cli's `capture`: on Linux the
+# microphone and the speakers link libasound at build time. Enable with
+# `cargo run -p moq-studio --features capture,openh264`.
+capture = ["moq-scene/capture", "moq-audio/playback"]
 # NVIDIA hardware codecs (NVENC + NVDEC) on Linux, as in moq-cli.
 nvidia = ["moq-video/nvidia"]
 # The vendored OpenH264 software H.264 fallback, opt-in like moq-video's.
@@ -42,7 +43,9 @@ anyhow = { workspace = true, features = ["backtrace"] }
 bytes = { workspace = true }
 # The window, its event loop, and the egui integration. `wgpu` is the renderer
 # the compositor shares a device with; no glow, no system font discovery.
-eframe = { version = "0.36", default-features = false, features = ["default_fonts", "wayland", "wgpu", "x11"] }
+# `persistence` keeps per-user picks, such as the output Listen plays on, out
+# of the shared scene file.
+eframe = { version = "0.36", default-features = false, features = ["default_fonts", "persistence", "wayland", "wgpu", "x11"] }
 egui = "0.36"
 # Docked, rearrangeable panels. 0.21 is the newest release and pins egui 0.36.
 egui_dock = "0.21"
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index ccc7582..6c10d3f 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -6,8 +6,9 @@
 //! Threads:
 //! - **program** draws preview and program once per canvas frame and hands the
 //!   program to the encoder, stamped with the program clock.
-//! - **audio** advances the audio bus on the same clock and publishes its
-//!   program mix.
+//! - **audio** advances the audio bus, and with it every mix, on the same
+//!   clock.
+//! - **audio-encode** encodes the mix on program into the program audio.
 //! - **encode**: one per program rendition, which waits for each program copy
 //!   and encodes it. A new canvas size or frame rate starts a new rendition.
 //! - Recordings write their files on the tokio runtime.
@@ -32,7 +33,7 @@ use moq_scene::{Canvas, Collection, Compositor, Draft, Edit, History, wgpu};
 use moq_video::render::export::{Exporter, Pending, Route};
 
 use crate::autosave::{self, Autosave};
-use crate::{health, record};
+use crate::{health, mix, record};
 
 /// The GPU everything shares: sources upload to it, the compositor draws on
 /// it, the window presents from it, and the encoder reads the program from it.
@@ -423,8 +424,10 @@ pub struct Engine {
 	pub stats: Arc<Stats>,
 	/// How the stream is delivered, graded every [`health::INTERVAL`].
 	pub health: Mutex<health::Report>,
-	/// The program audio, which every source with sound is routed into.
-	pub mix: moq_audio::bus::Mix,
+	/// The mix the program audio carries, as the collection picks it.
+	program_audio: mix::Pick,
+	/// Plays a mix to the speakers while the creator listens.
+	monitor: Mutex<Option<mix::Monitor>>,
 	/// `None` when running without a relay.
 	pub output: Option<Output>,
 	/// Records the program, and each source too if asked.
@@ -487,7 +490,6 @@ impl Engine {
 			room,
 		} = launch;
 		let (bus, mixer) = moq_audio::bus::Bus::new(Default::default())?;
-		let program_mix = bus.mix();
 		let subscribe = moq_tokio::origin::spawn();
 		// Every relay feeds `subscribe`, so a guest either one routes is seen.
 		let guests = match &room {
@@ -538,7 +540,6 @@ impl Engine {
 		let dir = std::path::absolute(dir.unwrap_or(Path::new(".")))?;
 		let sources = Sources::new(source::Context {
 			bus: bus.clone(),
-			program: program_mix.clone(),
 			origin: sources,
 			dir,
 			output: moq_video::render::output(&gpu.device),
@@ -563,7 +564,8 @@ impl Engine {
 			autosave,
 			stats,
 			health: Mutex::default(),
-			mix: program_mix,
+			program_audio: mix::Pick::default(),
+			monitor: Mutex::default(),
 			output,
 			recorder,
 			room,
@@ -592,8 +594,15 @@ impl Engine {
 		engine.threads.lock().unwrap().push(thread);
 		let mix = engine.clone();
 		let config = bus.config().clone();
-		let thread = clocked("audio".into(), async move || {
-			mix.run_audio(start, epoch, config, mixer, Some(audio)).await
+		let rate = config.sample_rate;
+		let thread = clocked("audio".into(), async move || mix.run_audio(start, config, mixer).await)?;
+		engine.threads.lock().unwrap().push(thread);
+		// Its own thread, so an encoder that falls behind skips its own audio
+		// rather than holding up the bus.
+		let encode = engine.clone();
+		let follow = engine.program_audio.follow();
+		let thread = clocked("audio-encode".into(), async move || {
+			encode.encode_audio(epoch, rate, follow, audio).await
 		})?;
 		engine.threads.lock().unwrap().push(thread);
 		let save = engine.clone();
@@ -649,6 +658,57 @@ impl Engine {
 		self.autosave.keep(&self.state)
 	}
 
+	/// Play a mix to an output on `runtime`, from the next frame, or stop with
+	/// `None`. A monitored mix that leaves the collection hands over to the one
+	/// the program carries, and another output takes over from the old one.
+	///
+	/// Takes the `state` already locked, so an edit renaming the mix and the
+	/// pick that follows it land before the next frame's sync.
+	pub fn listen(
+		&self,
+		state: &mut State,
+		runtime: &tokio::runtime::Handle,
+		listen: Option<mix::Listen<'_>>,
+	) -> anyhow::Result<()> {
+		let mut monitor = self.monitor.lock().unwrap();
+		match (listen, monitor.as_mut()) {
+			(None, _) => *monitor = None,
+			(Some(listen), Some(monitor)) if monitor.failed().is_none() => {
+				monitor.set_name(listen.mix);
+				monitor.set_speaker(listen.speaker);
+			}
+			// Listening again after a failure starts over.
+			(Some(listen), _) => *monitor = Some(mix::Monitor::start(runtime, listen.mix, listen.speaker)?),
+		}
+		// Synced on the next frame, which picks the mix by its name.
+		state.stale = true;
+		Ok(())
+	}
+
+	/// The mix played to the speakers, and why it stopped if it did.
+	pub fn listening(&self) -> Option<(String, Option<String>)> {
+		let monitor = self.monitor.lock().unwrap();
+		monitor
+			.as_ref()
+			.map(|monitor| (monitor.name().to_string(), monitor.failed()))
+	}
+
+	/// Point the program audio and the monitor at the mixes `state` now has.
+	fn pick_mixes(&self, state: &State) {
+		let mixes = &state.collection.mixes;
+		if let Some(mix) = state.sources.mix(&mixes.program) {
+			self.program_audio.set(mix.clone());
+		}
+		if let Some(monitor) = self.monitor.lock().unwrap().as_mut() {
+			if !mixes.names.iter().any(|name| name == monitor.name()) {
+				monitor.set_name(&mixes.program);
+			}
+			if let Some(mix) = state.sources.mix(monitor.name()) {
+				monitor.play(mix.clone());
+			}
+		}
+	}
+
 	/// Grade the stream's health every interval, for the Health panel.
 	async fn grade(self: Arc<Self>, mut sampler: health::Sampler) {
 		let mut interval = kio::clock::interval(health::INTERVAL);
@@ -664,8 +724,9 @@ impl Engine {
 	fn local(&self, now: Instant) -> health::Local {
 		let stats = &self.stats;
 		// A stalled picture matters where the program draws it: a scene on air,
-		// including one leaving in a transition, or the top layer over them. Stalled sound
-		// matters wherever the program plays it.
+		// including one leaving in a transition, or the top layer over them.
+		// Stalled sound matters only if the mix on program plays it, not one
+		// only listened to.
 		let stalled = {
 			let state = self.state.lock().unwrap();
 			let shown: Vec<&str> = state
@@ -684,7 +745,7 @@ impl Engine {
 					let stall = feed.stalled(now)?;
 					let matters = match stall {
 						source::Stall::Picture(_) => shown.contains(&name),
-						source::Stall::Sound(_) => feed.strip().is_some_and(|strip| !strip.muted()),
+						source::Stall::Sound(_) => state.sources.plays(&state.collection.mixes.program, name),
 					};
 					matters.then(|| (name.to_string(), stall))
 				})
@@ -762,6 +823,7 @@ impl Engine {
 					for driver in state.sources.sync(&state.collection) {
 						spawn(driver);
 					}
+					self.pick_mixes(state);
 				}
 				if let Err(err) = state.compositor.render(&state.collection, &state.sources, tick) {
 					tracing::error!(%err, "cannot draw the canvas");
@@ -850,33 +912,22 @@ impl Engine {
 		}
 	}
 
-	/// Advance the bus as the program clock advances, and publish the program
-	/// mix stamped `epoch` past `start`.
+	/// Advance the bus as the program clock advances, from `start`.
 	///
 	/// Runs without a relay too, so the meters move and sources never back up,
-	/// until the studio [stops](Self::stop), which finishes the audio track.
-	async fn run_audio(
-		&self,
-		start: Instant,
-		epoch: Duration,
-		config: moq_audio::bus::Config,
-		mut mixer: moq_audio::bus::Driver,
-		mut producer: Option<moq_audio::encode::Producer>,
-	) {
+	/// until the studio [stops](Self::stop), which ends every mix, so each
+	/// output reads its mix to the end.
+	async fn run_audio(&self, start: Instant, config: moq_audio::bus::Config, mut mixer: moq_audio::bus::Driver) {
 		let rate = u128::from(config.sample_rate);
 		let mut clock = kio::clock::interval_at(start, AUDIO_PERIOD);
 		clock.set_missed_tick_behavior(kio::clock::MissedTickBehavior::Skip);
-		let mut program = self.mix.reader();
 		let mut written: u128 = 0;
 
 		loop {
 			let tick = clock.tick().await;
 			if self.stopped.load(Ordering::Relaxed) {
-				if let Some(mut producer) = producer.take()
-					&& let Err(err) = producer.finish()
-				{
-					self.stats.fail_audio(err);
-				}
+				drop(mixer);
+				self.program_audio.close();
 				return;
 			}
 			// Sample-exact against the program clock, so audio and video stay
@@ -888,21 +939,44 @@ impl Engine {
 			}
 			mixer.advance(frames);
 			written = due;
-			let block = program.read().await.expect("the mixer is alive");
-			let position = u128::from(block.position);
-			let timestamp = moq_net::Timestamp::from_micros((epoch.as_micros() + position * 1_000_000 / rate) as u64);
+		}
+	}
 
-			let Some(publish) = producer.as_mut() else { continue };
-			let Ok(timestamp) = timestamp else { continue };
+	/// Encode the mix `follow` reads into the program audio, `producer`,
+	/// stamped `epoch` past the bus's start at `rate`, until the bus stops, and
+	/// finish the track.
+	async fn encode_audio(
+		&self,
+		epoch: Duration,
+		rate: u32,
+		mut follow: mix::Follow,
+		mut producer: moq_audio::encode::Producer,
+	) {
+		let rate = u128::from(rate);
+		let mut next = None;
+		while let Some(block) = follow.read().await {
+			// Audio this encoder fell too far behind to read leaves a gap in
+			// the track rather than pulling what follows early.
+			if next.is_some_and(|next| next != block.position) {
+				producer.reanchor();
+			}
+			next = Some(block.position + block.frames() as u64);
+			let position = u128::from(block.position);
+			let micros = epoch.as_micros() + position * 1_000_000 / rate;
+			let Ok(timestamp) = moq_net::Timestamp::from_micros(micros as u64) else {
+				continue;
+			};
 			let data: Vec<u8> = block.data.iter().flat_map(|sample| sample.to_le_bytes()).collect();
-			if let Err(err) = publish.write(&moq_audio::Frame::new(Bytes::from(data), timestamp)) {
+			if let Err(err) = producer.write(&moq_audio::Frame::new(Bytes::from(data), timestamp)) {
 				self.stats.fail_audio(err);
 				// Viewers see the audio fail rather than go away unfinished.
-				if let Some(producer) = producer.take() {
-					producer.abort(moq_net::StreamError::Internal.into());
-				}
+				producer.abort(moq_net::StreamError::Internal.into());
+				return;
 			}
 		}
+		if let Err(err) = producer.finish() {
+			self.stats.fail_audio(err);
+		}
 	}
 }
 
diff --git a/rs/moq-studio/src/guests.rs b/rs/moq-studio/src/guests.rs
index 6aba75a..a768435 100644
--- a/rs/moq-studio/src/guests.rs
+++ b/rs/moq-studio/src/guests.rs
@@ -524,7 +524,7 @@ impl Room {
 		}
 
 		for source in &sources {
-			let audio = before.audio.get(source).copied().unwrap_or_default();
+			let audio = before.audio.get(source).cloned().unwrap_or_default();
 			draft.set_audio(source, Some(moq_scene::Audio { muted: true, ..audio }))?;
 		}
 		Ok(*draft.collection() != before)
diff --git a/rs/moq-studio/src/main.rs b/rs/moq-studio/src/main.rs
index c2837d8..f08ee87 100644
--- a/rs/moq-studio/src/main.rs
+++ b/rs/moq-studio/src/main.rs
@@ -16,6 +16,7 @@ mod engine;
 mod guests;
 mod health;
 mod interact;
+mod mix;
 mod record;
 mod replay;
 mod setup;
@@ -235,10 +236,17 @@ impl eframe::App for Window {
 			App::Starting(engine) => engine.clone(),
 		};
 		let _ = self.started.set(engine.clone());
-		let studio = ui::Studio::new(&self.render, engine, self.runtime.clone());
+		let mut studio = ui::Studio::new(&self.render, engine, self.runtime.clone());
+		studio.load(frame.storage());
 		self.app = App::Studio(Box::new(studio));
 		ui.ctx().request_repaint();
 	}
+
+	fn save(&mut self, storage: &mut dyn eframe::Storage) {
+		if let App::Studio(studio) = &mut self.app {
+			studio.save(storage);
+		}
+	}
 }
 
 /// Show the window until it is closed.
diff --git a/rs/moq-studio/src/mix.rs b/rs/moq-studio/src/mix.rs
new file mode 100644
index 0000000..f36968e
--- /dev/null
+++ b/rs/moq-studio/src/mix.rs
@@ -0,0 +1,456 @@
+//! Outputs that read one of the collection's mixes: the program audio and
+//! the headphone monitor.
+//!
+//! Each output follows a [`Pick`], which the program clock sets from the
+//! collection, and reads the picked mix on its own thread or task. A mix's
+//! reader never holds the bus up, so an output that falls behind loses only
+//! its own audio.
+
+use std::sync::{Arc, Mutex};
+use std::task::{Poll, ready};
+
+use moq_audio::bus::{Block, Mix, Reader};
+
+/// Which mix an output reads, as last picked.
+#[derive(Clone, Default)]
+pub struct Pick(kio::Producer<Picked>);
+
+#[derive(Default)]
+struct Picked {
+	/// How many times a mix was picked, so a reader sees each pick once.
+	generation: u64,
+	/// The mix, and a reader starting at the first block after the pick.
+	mix: Option<(Mix, Reader)>,
+}
+
+impl Pick {
+	/// Read `mix` from its next block on. Picking the mix already read
+	/// changes nothing a reader hears.
+	pub fn set(&self, mix: Mix) {
+		let reader = mix.reader();
+		// Fails only once every handle is gone, when nothing reads it.
+		if let Ok(mut picked) = self.0.write() {
+			picked.generation += 1;
+			picked.mix = Some((mix, reader));
+		}
+	}
+
+	/// Pick nothing more, as the bus stops: a reader that never got a mix
+	/// ends, and one that did reads it to its end.
+	pub fn close(&self) {
+		let _ = self.0.close();
+	}
+
+	/// A reader of whichever mix is picked, starting with the next pick or
+	/// the current one.
+	pub fn follow(&self) -> Follow {
+		Follow {
+			pick: self.0.consume(),
+			seen: 0,
+			end: 0,
+			current: None,
+			next: None,
+		}
+	}
+}
+
+/// Reads the blocks of the [`Pick`]ed mix, switching between mixes on a block
+/// boundary, so a new pick neither drops nor repeats a block.
+pub struct Follow {
+	pick: kio::Consumer<Picked>,
+	/// The generation of the pick read last.
+	seen: u64,
+	/// Where the block after the last one read starts, which a new pick
+	/// starts at or after.
+	end: u64,
+	/// The mix being read, held so it outlives a pick that drops it from the
+	/// collection until the next one takes over.
+	current: Option<(Mix, Reader)>,
+	/// The mix picked since, with its first block once read, until the
+	/// current one has caught up to it.
+	next: Option<(Mix, Reader, Option<Block>)>,
+}
+
+impl Follow {
+	/// The next block of the picked mix, or `None` once the bus has stopped and
+	/// every block kept for this reader has been read. Waits for a first pick.
+	pub fn poll_read(&mut self, waiter: &kio::Waiter) -> Poll<Option<Block>> {
+		let block = ready!(self.poll_next(waiter));
+		if let Some(block) = &block {
+			self.end = block.position + block.frames() as u64;
+		}
+		Poll::Ready(block)
+	}
+
+	fn poll_next(&mut self, waiter: &kio::Waiter) -> Poll<Option<Block>> {
+		let seen = self.seen;
+		let picked = self.pick.poll(waiter, |picked| match &picked.mix {
+			Some(mix) if picked.generation != seen => Poll::Ready((picked.generation, mix.clone())),
+			_ => Poll::Pending,
+		});
+		let picked = picked.map(Result::ok);
+		// Closed once the bus stops, leaving no pick to wait for.
+		let mut ended = matches!(picked, Poll::Ready(None));
+		if let Poll::Ready(Some((generation, (mix, reader)))) = picked {
+			self.seen = generation;
+			self.next = Some((mix, reader, None));
+		}
+
+		while let Some((_, reader, first @ None)) = &mut self.next {
+			match reader.poll_read(waiter) {
+				// Already read from the current mix, which the bus advanced
+				// since this mix was picked.
+				Poll::Ready(Some(block)) if block.position < self.end => {}
+				Poll::Ready(Some(block)) => *first = Some(block),
+				// The bus stopped, so the current mix ends too.
+				Poll::Ready(None) => {
+					self.next = None;
+					ended = true;
+				}
+				Poll::Pending => break,
+			}
+		}
+		let first = match &self.next {
+			Some((_, _, Some(first))) => Some(first.position),
+			_ => None,
+		};
+
+		let block = match &mut self.current {
+			Some((_, reader)) => ready!(reader.poll_read(waiter)),
+			// Nothing read yet, so the next mix starts at its first block.
+			None if first.is_some() => return Poll::Ready(self.switch()),
+			None if ended && self.next.is_none() => return Poll::Ready(None),
+			None => return Poll::Pending,
+		};
+		match (block, first) {
+			// Every mix advances on the one clock, so the current mix reaches
+			// the next one's first block, which takes over from there.
+			(Some(block), Some(first)) if block.position < first => Poll::Ready(Some(block)),
+			(_, Some(_)) => Poll::Ready(self.switch()),
+			(block, None) => Poll::Ready(block),
+		}
+	}
+
+	/// Read the next mix from now on, starting with its first block.
+	fn switch(&mut self) -> Option<Block> {
+		let (mix, reader, first) = self.next.take()?;
+		self.current = Some((mix, reader));
+		first
+	}
+
+	/// The next block of the picked mix, or `None` once the bus has stopped.
+	pub async fn read(&mut self) -> Option<Block> {
+		kio::wait(|waiter| self.poll_read(waiter)).await
+	}
+}
+
+/// Whether this build can play a mix to the speakers: the `capture` feature
+/// brings the device's audio library.
+pub const MONITOR: bool = cfg!(feature = "capture");
+
+/// What to listen to, and where.
+#[derive(Clone, Copy, Debug)]
+pub struct Listen<'a> {
+	/// The mix, by name.
+	pub mix: &'a str,
+	/// The [`Speaker::id`] to play on, or `None` for the system default.
+	pub speaker: Option<&'a str>,
+}
+
+/// An audio output this machine has, to listen on.
+#[derive(Clone, Debug)]
+pub struct Speaker {
+	/// What [`Monitor::start`] opens it by.
+	pub id: String,
+	/// The device's name and the host API it is reached through.
+	pub name: String,
+}
+
+/// This machine's audio outputs, or why they cannot be listed.
+#[cfg(feature = "capture")]
+pub async fn speakers() -> Result<Vec<Speaker>, String> {
+	let devices = moq_audio::playback::devices().await.map_err(|err| err.to_string())?;
+	let speakers = devices.into_iter().map(|device| Speaker {
+		name: format!("{} ({})", device.name, device.host),
+		id: device.id,
+	});
+	Ok(speakers.collect())
+}
+
+#[cfg(not(feature = "capture"))]
+pub async fn speakers() -> Result<Vec<Speaker>, String> {
+	Err("listening needs a build with the `capture` feature".into())
+}
+
+/// Plays one mix to an audio output, for headphones.
+///
+/// Stops when dropped.
+pub struct Monitor {
+	/// The mix it plays, by name.
+	name: String,
+	/// The [`Speaker::id`] it plays on, or `None` for the system default.
+	speaker: tokio::sync::watch::Sender<Option<String>>,
+	pick: Pick,
+	failed: Arc<Mutex<Option<String>>>,
+	task: tokio::task::JoinHandle<()>,
+}
+
+impl Monitor {
+	/// Open the output `speaker`, or the system default, on `runtime`, to play
+	/// the mix called `name` once it is [given](Self::play). Fails in a build
+	/// without [`MONITOR`].
+	pub fn start(runtime: &tokio::runtime::Handle, name: &str, speaker: Option<&str>) -> anyhow::Result<Self> {
+		anyhow::ensure!(MONITOR, "listening needs a build with the `capture` feature");
+		let pick = Pick::default();
+		let follow = pick.follow();
+		let failed = Arc::new(Mutex::new(None));
+		let reason = failed.clone();
+		let (speaker, speakers) = tokio::sync::watch::channel(speaker.map(str::to_string));
+		let task = runtime.spawn(async move {
+			if let Err(err) = play(follow, speakers).await {
+				tracing::warn!(error = format!("{err:#}"), "the monitor stopped");
+				*reason.lock().unwrap() = Some(format!("{err:#}"));
+			}
+		});
+		Ok(Self {
+			name: name.to_string(),
+			speaker,
+			pick,
+			failed,
+			task,
+		})
+	}
+
+	/// The name of the mix it plays.
+	pub fn name(&self) -> &str {
+		&self.name
+	}
+
+	/// Move to the output `speaker`, or the system default, closing the one it
+	/// plays on first.
+	pub fn set_speaker(&self, speaker: Option<&str>) {
+		self.speaker.send_if_modified(|current| {
+			let changed = current.as_deref() != speaker;
+			*current = speaker.map(str::to_string);
+			changed
+		});
+	}
+
+	/// Play the mix called `name` once it is given.
+	pub fn set_name(&mut self, name: &str) {
+		self.name = name.to_string();
+	}
+
+	/// Play `mix`, the one [named](Self::name), from its next block on.
+	pub fn play(&self, mix: Mix) {
+		self.pick.set(mix);
+	}
+
+	/// Why it stopped playing, if it did.
+	pub fn failed(&self) -> Option<String> {
+		self.failed.lock().unwrap().clone()
+	}
+}
+
+impl Drop for Monitor {
+	fn drop(&mut self) {
+		self.task.abort();
+	}
+}
+
+/// Play what `follow` reads out the output `speakers` names, or the system
+/// default, until the bus stops, moving as it names another.
+#[cfg(feature = "capture")]
+async fn play(mut follow: Follow, mut speakers: tokio::sync::watch::Receiver<Option<String>>) -> anyhow::Result<()> {
+	use anyhow::Context;
+
+	let output = |device: Option<String>| {
+		let mut config = moq_audio::playback::Config::default();
+		config.device = device;
+		config
+	};
+	let device = speakers.borrow_and_update().clone();
+	let device = moq_audio::playback::Engine::open(output(device))
+		.await
+		.context("cannot open the output device")?;
+	let config = moq_audio::bus::Config::default();
+	let mut input = moq_audio::playback::Input::default();
+	input.format = moq_audio::Format::F32;
+	input.sample_rate = config.sample_rate;
+	input.layout = config.layout;
+	let mut sink = device.sink(input)?;
+	loop {
+		tokio::select! {
+			block = follow.read() => {
+				let Some(block) = block else { return Ok(()) };
+				let data: Vec<u8> = block.data.iter().flat_map(|sample| sample.to_le_bytes()).collect();
+				// What the device cannot take is dropped rather than played late.
+				let _ = sink.write(&data)?;
+			}
+			// Closes the old stream before opening the new, which an output
+			// only one stream may hold needs; the sink plays on.
+			Ok(()) = speakers.changed() => {
+				let speaker = speakers.borrow_and_update().clone();
+				device.switch(output(speaker)).await.context("cannot switch the output device")?;
+			}
+		}
+	}
+}
+
+#[cfg(not(feature = "capture"))]
+async fn play(_follow: Follow, _speakers: tokio::sync::watch::Receiver<Option<String>>) -> anyhow::Result<()> {
+	unreachable!("refused by Monitor::start")
+}
+
+#[cfg(test)]
+mod tests {
+	use moq_audio::bus::{Bus, Channel, Driver, Strip};
+
+	use super::*;
+
+	/// The default bus's 10 ms block.
+	const BLOCK: usize = 480;
+
+	/// A stereo source the test feeds `value` one block per advance.
+	fn source(bus: &Bus) -> (Channel, Strip) {
+		let strip = Strip::default();
+		let mut input = moq_audio::encode::Input::new(48_000, moq_audio::Layout::Stereo);
+		input.format = moq_audio::Format::F32;
+		(bus.channel(input, strip.clone()).unwrap(), strip)
+	}
+
+	fn feed(channel: &mut Channel, value: f32) {
+		let data: Vec<u8> = std::iter::repeat_n(value, BLOCK * 2)
+			.flat_map(f32::to_le_bytes)
+			.collect();
+		channel.write(&data).unwrap();
+	}
+
+	/// The block `follow` already has waiting.
+	fn ready(follow: &mut Follow) -> Option<Block> {
+		match follow.poll_read(&kio::Waiter::noop()) {
+			Poll::Ready(block) => block,
+			Poll::Pending => panic!("no block waiting"),
+		}
+	}
+
+	/// Two mixes of one source each, `a` playing 0.25 and `b` 0.5, run past
+	/// the bus's latency so each mix carries its source.
+	fn mixes() -> (Driver, Mix, Mix, [Channel; 2]) {
+		let (bus, mut driver) = Bus::new(Default::default()).unwrap();
+		let (mut quiet, quiet_strip) = source(&bus);
+		let (mut loud, loud_strip) = source(&bus);
+		let a = bus.mix();
+		a.route(&quiet_strip);
+		let b = bus.mix();
+		b.route(&loud_strip);
+		driver.advance(BLOCK);
+		for _ in 0..20 {
+			feed(&mut quiet, 0.25);
+			feed(&mut loud, 0.5);
+			driver.advance(BLOCK);
+		}
+		(driver, a, b, [quiet, loud])
+	}
+
+	/// Switching mixes, even while the output lags, plays every position once.
+	#[test]
+	fn a_new_pick_neither_drops_nor_repeats_a_block() {
+		let (mut driver, a, b, [mut quiet, mut loud]) = mixes();
+		let pick = Pick::default();
+		let mut follow = pick.follow();
+		assert!(
+			follow.poll_read(&kio::Waiter::noop()).is_pending(),
+			"nothing picked yet"
+		);
+
+		pick.set(a.clone());
+		let mut step = |driver: &mut Driver| {
+			feed(&mut quiet, 0.25);
+			feed(&mut loud, 0.5);
+			driver.advance(BLOCK);
+		};
+		step(&mut driver);
+		let first = ready(&mut follow).unwrap();
+		assert_eq!(first.data[0], 0.25);
+
+		// Two blocks behind when the pick changes: both still come from `a`.
+		step(&mut driver);
+		step(&mut driver);
+		pick.set(b.clone());
+		step(&mut driver);
+		let mut heard = Vec::new();
+		while let Poll::Ready(Some(block)) = follow.poll_read(&kio::Waiter::noop()) {
+			heard.push((block.position, block.data[0]));
+		}
+		let at = |n: u64| first.position + n * BLOCK as u64;
+		assert_eq!(heard, [(at(1), 0.25), (at(2), 0.25), (at(3), 0.5)]);
+
+		// Picking the mix already read changes nothing.
+		pick.set(b.clone());
+		step(&mut driver);
+		assert_eq!(
+			ready(&mut follow).map(|block| (block.position, block.data[0])),
+			Some((at(4), 0.5))
+		);
+
+		drop(driver);
+		assert!(ready(&mut follow).is_none(), "the bus stopped");
+	}
+
+	/// A pick whose reader starts at a block the follower already read, as one
+	/// made while the bus advances can, starts after it instead.
+	#[test]
+	fn a_pick_never_replays_a_block() {
+		let (mut driver, a, b, [mut quiet, mut loud]) = mixes();
+		let pick = Pick::default();
+		let mut follow = pick.follow();
+		let mut step = |driver: &mut Driver| {
+			feed(&mut quiet, 0.25);
+			feed(&mut loud, 0.5);
+			driver.advance(BLOCK);
+		};
+		pick.set(a.clone());
+		step(&mut driver);
+		ready(&mut follow).unwrap();
+		let late = b.reader();
+		step(&mut driver);
+		let read = ready(&mut follow).unwrap();
+		{
+			let mut picked = pick.0.write().ok().unwrap();
+			picked.generation += 1;
+			picked.mix = Some((b.clone(), late));
+		}
+		step(&mut driver);
+		let next = ready(&mut follow).unwrap();
+		assert_eq!(next.position, read.position + BLOCK as u64, "read once");
+		assert_eq!(next.data[0], 0.5);
+	}
+
+	/// A follower that stops reading holds up neither the bus nor another reader.
+	#[test]
+	fn a_stalled_output_loses_only_its_own_audio() {
+		let (mut driver, a, _b, [mut quiet, _loud]) = mixes();
+		let pick = Pick::default();
+		pick.set(a.clone());
+		let mut stalled = pick.follow();
+		let mut live = pick.follow();
+		feed(&mut quiet, 0.25);
+		driver.advance(BLOCK);
+		let start = ready(&mut stalled).unwrap().position;
+		assert_eq!(ready(&mut live).unwrap().position, start);
+
+		// A second's worth, read by `live` only.
+		for index in 1..=100u64 {
+			feed(&mut quiet, 0.25);
+			driver.advance(BLOCK);
+			let block = ready(&mut live).unwrap();
+			assert_eq!(block.position, start + index * BLOCK as u64, "never held up");
+		}
+		let resumed = ready(&mut stalled).unwrap();
+		assert!(
+			resumed.position > start + BLOCK as u64,
+			"the stalled output skipped ahead"
+		);
+	}
+}
diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs
index 4a9b53a..1225d85 100644
--- a/rs/moq-studio/src/ui.rs
+++ b/rs/moq-studio/src/ui.rs
@@ -21,9 +21,9 @@ use crate::devices::{self, Listing, Pick};
 use crate::engine::{Engine, State};
 use crate::health::{self, Verdict};
 use crate::interact::Interact;
-use crate::record;
 use crate::replay::{self, Of};
 use crate::snap::{self, Grab, Snap};
+use crate::{mix, record};
 
 /// The panels, each a tab the user can move, split, or stack.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -109,6 +109,10 @@ impl Studio {
 				drag: None,
 				new_scene: String::new(),
 				renaming: None,
+				new_mix: String::new(),
+				renaming_mix: None,
+				speaker: None,
+				speakers: Speakers::default(),
 				canvas: None,
 				new_item: None,
 				add: AddSource::default(),
@@ -128,7 +132,23 @@ impl Studio {
 	}
 }
 
+/// Where the output Listen plays on is kept, per user.
+const SPEAKER: &str = "speaker";
+
+impl Studio {
+	/// Take up what this user picked last time, from `storage`.
+	pub fn load(&mut self, storage: Option<&dyn eframe::Storage>) {
+		if let Some(storage) = storage {
+			self.panels.speaker = eframe::get_value::<Option<String>>(storage, SPEAKER).flatten();
+		}
+	}
+}
+
 impl eframe::App for Studio {
+	fn save(&mut self, storage: &mut dyn eframe::Storage) {
+		eframe::set_value(storage, SPEAKER, &self.panels.speaker);
+	}
+
 	fn ui(&mut self, ui: &mut Ui, frame: &mut eframe::Frame) {
 		let engine = self.panels.engine.clone();
 		let state = engine.state.lock().unwrap();
@@ -216,6 +236,13 @@ struct Panels {
 	new_scene: String,
 	/// The scene being renamed, by index, and the name typed so far.
 	renaming: Option<(usize, String)>,
+	new_mix: String,
+	/// The mix being renamed, by its name, and the name typed so far.
+	renaming_mix: Option<(String, String)>,
+	/// The output Listen plays on, by [`mix::Speaker::id`], or `None` for the
+	/// system default. Saved per user, not in the shared scene file.
+	speaker: Option<String>,
+	speakers: Speakers,
 	/// The canvas the Output panel's form holds until it is applied, or
 	/// `None` while it shows the collection's.
 	canvas: Option<Canvas>,
@@ -1703,41 +1730,183 @@ impl Panels {
 		self.check(result);
 	}
 
+	/// The mixes, which the program carries and which plays to the speakers,
+	/// and each source's gain, mute, delay, and routing.
 	fn audio(&mut self, ui: &mut Ui) {
+		let engine = self.engine.clone();
+		let mut state = engine.state.lock().unwrap();
+		let mixes = state.collection().mixes.clone();
+		let listening = engine.listening();
+		let mut action = None;
+		let mut listen = None;
+
+		egui::Grid::new("mixes").show(ui, |ui| {
+			for name in &mixes.names {
+				if let Some((renaming, typed)) = &mut self.renaming_mix
+					&& renaming == name
+				{
+					let response = ui.text_edit_singleline(typed);
+					if !response.has_focus() && !response.lost_focus() {
+						response.request_focus();
+					}
+					if response.lost_focus() {
+						// Escape cancels; Enter or a click away renames.
+						if !ui.input(|input| input.key_pressed(egui::Key::Escape)) {
+							action = Some(MixAction::Rename(name.clone(), typed.trim().to_string()));
+						}
+						self.renaming_mix = None;
+					}
+				} else if ui.label(name).double_clicked() {
+					self.renaming_mix = Some((name.clone(), name.clone()));
+				}
+				meter(ui, state.sources.mix(name).map(|mix| mix.level()).unwrap_or_default());
+				if ui.radio(mixes.program == *name, "On program").clicked() && mixes.program != *name {
+					action = Some(MixAction::Program(name.clone()));
+				}
+				let heard = listening.as_ref().is_some_and(|(heard, _)| heard == name);
+				let response = ui
+					.add_enabled(mix::MONITOR, egui::Button::selectable(heard, "Listen"))
+					.on_hover_text("Play this mix to the speakers; use headphones")
+					.on_disabled_hover_text("Needs a build with the `capture` feature");
+				if response.clicked() {
+					listen = Some((!heard).then(|| name.clone()));
+				}
+				if ui.small_button("Rename").clicked() {
+					self.renaming_mix = Some((name.clone(), name.clone()));
+				}
+				if ui
+					.add_enabled(mixes.program != *name, egui::Button::new("Remove").small())
+					.on_disabled_hover_text("On program; put another mix on program first")
+					.clicked()
+				{
+					action = Some(MixAction::Remove(name.clone()));
+				}
+				ui.end_row();
+			}
+		});
 		ui.horizontal(|ui| {
-			ui.strong("Program");
-			meter(ui, self.engine.mix.level());
+			ui.text_edit_singleline(&mut self.new_mix);
+			if ui.button("Add mix").clicked() {
+				action = Some(MixAction::Add(self.new_mix.trim().to_string()));
+			}
 		});
+		if mix::MONITOR && self.speakers.ui(ui, &self.runtime, &mut self.speaker) {
+			// The monitor moves to the new output.
+			if let Some((heard, _)) = &listening {
+				listen = Some(Some(heard.clone()));
+			}
+		}
+		if let Some((_, Some(failed))) = &listening {
+			ui.colored_label(ui.visuals().error_fg_color, format!("Listening stopped: {failed}"));
+		}
 		ui.separator();
 
-		let engine = self.engine.clone();
-		let mut state = engine.state.lock().unwrap();
 		let mut change = None;
 		egui::Grid::new("audio").striped(true).show(ui, |ui| {
+			ui.label("");
+			ui.label("");
+			ui.label("Gain");
+			ui.label("Delay")
+				.on_hover_text("Hold the source back to line it up with a camera that lags it");
+			for name in &mixes.names {
+				ui.label(name);
+			}
+			ui.end_row();
 			for (name, feed) in state.sources.iter() {
 				let Some(strip) = feed.strip() else { continue };
-				let mut audio = state.collection().audio.get(name).copied().unwrap_or_default();
+				let mut audio = state.collection().audio.get(name).cloned().unwrap_or_default();
 				let mut db = decibels(audio.gain);
 				ui.label(name);
 				if ui.checkbox(&mut audio.muted, "Mute").changed() {
 					let verb = if audio.muted { "Mute" } else { "Unmute" };
-					change = Some((name.to_string(), audio, format!("{verb} `{name}`"), None));
+					change = Some((name.to_string(), audio.clone(), format!("{verb} `{name}`"), None));
 				}
 				let response = ui.add(egui::Slider::new(&mut db, MUTE_DB..=12.0).suffix(" dB"));
 				let gesture = self.gestures.of(&response);
 				if response.changed() {
+					let mut audio = audio.clone();
 					audio.gain = if db <= MUTE_DB { 0.0 } else { 10f32.powf(db / 20.0) };
 					change = Some((name.to_string(), audio, format!("Set `{name}` gain"), gesture));
 				}
+				let max = moq_audio::bus::MAX_DELAY.as_millis() as u64;
+				let mut millis = audio.delay.as_millis() as u64;
+				let response = ui.add(egui::DragValue::new(&mut millis).range(0..=max).suffix(" ms"));
+				let gesture = self.gestures.of(&response);
+				if response.changed() {
+					let mut audio = audio.clone();
+					audio.delay = Duration::from_millis(millis);
+					change = Some((name.to_string(), audio, format!("Set `{name}` delay"), gesture));
+				}
+				for mix in &mixes.names {
+					let mut routed = !audio.exclude.contains(mix);
+					if ui.checkbox(&mut routed, "").changed() {
+						let mut audio = audio.clone();
+						let label = if routed {
+							audio.exclude.remove(mix);
+							format!("Add `{name}` to `{mix}`")
+						} else {
+							audio.exclude.insert(mix.clone());
+							format!("Leave `{name}` out of `{mix}`")
+						};
+						change = Some((name.to_string(), audio, label, None));
+					}
+				}
 				meter(ui, strip.level());
 				ui.end_row();
 			}
 		});
+
+		let mut result = Ok(());
 		if let Some((name, audio, label, gesture)) = change {
-			let result = edit(&mut state, label, gesture, |draft| draft.set_audio(&name, Some(audio)));
-			drop(state);
-			self.check(result);
+			result = edit(&mut state, label, gesture, |draft| draft.set_audio(&name, Some(audio)));
+		}
+		if let Some(action) = action {
+			result = result.and(match action {
+				MixAction::Add(name) => {
+					let mut next = mixes.clone();
+					next.names.push(name.clone());
+					let added = edit(&mut state, format!("Add mix `{name}`"), None, |draft| {
+						draft.set_mixes(next)
+					});
+					if added.is_ok() {
+						self.new_mix.clear();
+					}
+					added
+				}
+				MixAction::Rename(from, to) if from == to => Ok(()),
+				MixAction::Rename(from, to) => {
+					let renamed = edit(&mut state, format!("Rename mix `{from}` to `{to}`"), None, |draft| {
+						draft.rename_mix(&from, &to)
+					});
+					// Listening follows the mix to its new name.
+					if renamed.is_ok() && listening.as_ref().is_some_and(|(heard, _)| *heard == from) {
+						listen = Some(Some(to));
+					}
+					renamed
+				}
+				MixAction::Program(name) => {
+					let next = moq_scene::Mixes {
+						program: name.clone(),
+						..mixes.clone()
+					};
+					edit(&mut state, format!("Put mix `{name}` on program"), None, |draft| {
+						draft.set_mixes(next)
+					})
+				}
+				MixAction::Remove(name) => edit(&mut state, format!("Remove mix `{name}`"), None, |draft| {
+					draft.remove_mix(&name)
+				}),
+			});
+		}
+		if let Some(listen) = listen {
+			let listen = listen.as_deref().map(|mix| mix::Listen {
+				mix,
+				speaker: self.speaker.as_deref(),
+			});
+			result = result.and(engine.listen(&mut state, &self.runtime, listen));
 		}
+		drop(state);
+		self.check(result);
 	}
 
 	/// Start and stop recording, and see what the recording wrote.
@@ -2239,6 +2408,16 @@ impl SceneAction {
 	}
 }
 
+/// An edit the Audio panel makes to the mixes, each named.
+enum MixAction {
+	Add(String),
+	/// From one name to the other.
+	Rename(String, String),
+	/// Put the mix on program.
+	Program(String),
+	Remove(String),
+}
+
 /// An edit the Items panel makes.
 enum ItemAction {
 	/// Replace the item at an index, labelled, as part of a gesture.
@@ -3039,6 +3218,60 @@ impl Default for Replay {
 	}
 }
 
+/// The audio outputs Listen can play on, listed once the Audio panel is shown
+/// and again on Refresh.
+#[derive(Default)]
+struct Speakers {
+	listing: Option<Result<Vec<mix::Speaker>, String>>,
+	pending: Option<std::sync::mpsc::Receiver<Result<Vec<mix::Speaker>, String>>>,
+}
+
+impl Speakers {
+	/// Pick the output `speaker` names, or `None` for the system default.
+	/// Returns whether the pick changed.
+	fn ui(&mut self, ui: &mut Ui, runtime: &tokio::runtime::Handle, speaker: &mut Option<String>) -> bool {
+		if let Some(listing) = self.pending.as_ref().and_then(|pending| pending.try_recv().ok()) {
+			self.listing = Some(listing);
+			self.pending = None;
+		}
+		let mut refresh = self.listing.is_none() && self.pending.is_none();
+		let before = speaker.clone();
+		ui.horizontal(|ui| {
+			ui.label("Listen on");
+			let speakers = self.listing.as_ref().and_then(|listing| listing.as_ref().ok());
+			let named = |id: &str| {
+				let found = speakers.and_then(|speakers| speakers.iter().find(|speaker| speaker.id == id));
+				found.map_or_else(|| format!("{id} (not found)"), |speaker| speaker.name.clone())
+			};
+			let shown = speaker.as_deref().map_or_else(|| "System default".to_string(), named);
+			egui::ComboBox::from_id_salt("speaker")
+				.selected_text(shown)
+				.show_ui(ui, |ui| {
+					ui.selectable_value(speaker, None, "System default");
+					for found in speakers.into_iter().flatten() {
+						ui.selectable_value(speaker, Some(found.id.clone()), &found.name);
+					}
+				});
+			if self.pending.is_some() {
+				ui.spinner();
+			} else if ui.small_button("Refresh").clicked() {
+				refresh = true;
+			}
+		});
+		if let Some(Err(err)) = &self.listing {
+			ui.colored_label(ui.visuals().error_fg_color, format!("Cannot list the outputs: {err}"));
+		}
+		if refresh {
+			let (send, recv) = std::sync::mpsc::channel();
+			runtime.spawn(async move {
+				let _ = send.send(mix::speakers().await);
+			});
+			self.pending = Some(recv);
+		}
+		*speaker != before
+	}
+}
+
 /// The capture devices this machine has, listed in the background.
 #[derive(Default)]
 struct Devices {
diff --git a/rs/moq-studio/tests/browser.rs b/rs/moq-studio/tests/browser.rs
index 0b8c898..2a1af49 100644
--- a/rs/moq-studio/tests/browser.rs
+++ b/rs/moq-studio/tests/browser.rs
@@ -75,7 +75,6 @@ impl Studio {
 		let (bus, mixer) = moq_audio::bus::Bus::new(Default::default()).unwrap();
 		let helper = Helper::new(env!("CARGO_BIN_EXE_moq-studio"), profile, &adapter, &device, &queue);
 		let mut sources = Sources::new(Context {
-			program: bus.mix(),
 			bus,
 			origin: origin.consume(),
 			dir: dir.path().to_path_buf(),