diff --git a/Cargo.lock b/Cargo.lock
index 89f2cc83d4..a0fad2ad34 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -947,6 +947,14 @@ dependencies = [
  "windows-core 0.60.1",
 ]
 
+[[package]]
+name = "cap-cpal-ffmpeg"
+version = "0.1.0"
+dependencies = [
+ "cpal 0.16.0",
+ "ffmpeg-next",
+]
+
 [[package]]
 name = "cap-cursor-capture"
 version = "0.1.0"
@@ -1006,6 +1014,7 @@ dependencies = [
  "futures-intrusive",
  "global-hotkey",
  "image 0.25.6",
+ "kameo",
  "keyed_priority_queue",
  "lazy_static",
  "log",
@@ -1158,6 +1167,7 @@ dependencies = [
  "cap-camera",
  "cap-camera-ffmpeg",
  "cap-camera-windows",
+ "cap-cpal-ffmpeg",
  "cap-displays",
  "cap-fail",
  "cap-flags",
@@ -1275,6 +1285,7 @@ dependencies = [
  "objc",
  "objc2-app-kit",
  "relative-path",
+ "replace_with",
  "ringbuf",
  "scap-cpal",
  "scap-direct3d",
@@ -3773,7 +3784,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.58.0",
+ "windows-core 0.61.2",
 ]
 
 [[package]]
@@ -4435,7 +4446,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667"
 dependencies = [
  "cfg-if",
- "windows-targets 0.48.5",
+ "windows-targets 0.53.3",
 ]
 
 [[package]]
@@ -6633,6 +6644,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832"
 
+[[package]]
+name = "replace_with"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51743d3e274e2b18df81c4dc6caf8a5b8e15dbe799e0dca05c7617380094e884"
+
 [[package]]
 name = "reqwest"
 version = "0.12.22"
@@ -10146,7 +10163,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
diff --git a/apps/cli/src/record.rs b/apps/cli/src/record.rs
index b8f3952aea..aed946e096 100644
--- a/apps/cli/src/record.rs
+++ b/apps/cli/src/record.rs
@@ -65,7 +65,7 @@ impl RecordStart {
             cap_recording::RecordingBaseInputs {
                 capture_target: target_info,
                 capture_system_audio: self.system_audio,
-                mic_feed: &None,
+                mic_feed: None,
             },
             camera.map(|c| Arc::new(Mutex::new(c))),
             false,
diff --git a/apps/desktop/src-tauri/Cargo.toml b/apps/desktop/src-tauri/Cargo.toml
index 4d13c21bf4..7c49e88664 100644
--- a/apps/desktop/src-tauri/Cargo.toml
+++ b/apps/desktop/src-tauri/Cargo.toml
@@ -101,6 +101,7 @@ md5 = "0.7.0"
 tokio-util = "0.7.15"
 wgpu.workspace = true
 bytemuck = "1.23.1"
+kameo = "0.17.2"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 core-graphics = "0.24.0"
diff --git a/apps/desktop/src-tauri/src/audio_meter.rs b/apps/desktop/src-tauri/src/audio_meter.rs
index b5bd335a7b..e7cd067dea 100644
--- a/apps/desktop/src-tauri/src/audio_meter.rs
+++ b/apps/desktop/src-tauri/src/audio_meter.rs
@@ -1,4 +1,4 @@
-use cap_recording::feeds::{AudioInputSamples, AudioInputSamplesReceiver};
+use cap_recording::feeds::microphone::MicrophoneSamples;
 use cpal::{SampleFormat, StreamInstant};
 use keyed_priority_queue::KeyedPriorityQueue;
 use serde::{Deserialize, Serialize};
@@ -15,7 +15,10 @@ const MIN_DB: f64 = -96.0;
 #[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
 pub struct AudioInputLevelChange(f64);
 
-pub fn spawn_event_emitter(app_handle: AppHandle, audio_input_rx: AudioInputSamplesReceiver) {
+pub fn spawn_event_emitter(
+    app_handle: AppHandle,
+    audio_input_rx: flume::Receiver<MicrophoneSamples>,
+) {
     let mut time_window = VolumeMeter::new(0.2);
     tokio::spawn(async move {
         while let Ok(samples) = audio_input_rx.recv_async().await {
@@ -106,7 +109,7 @@ fn db_fs(data: impl Iterator<Item = f64>) -> f64 {
     (20.0 * (max as f64 / MAX_AMPLITUDE_F32).log10()).clamp(MIN_DB, 0.0)
 }
 
-fn samples_to_f64(samples: &AudioInputSamples) -> impl Iterator<Item = f64> + use<'_> {
+fn samples_to_f64(samples: &MicrophoneSamples) -> impl Iterator<Item = f64> + use<'_> {
     samples
         .data
         .chunks(samples.format.sample_size())
diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index 2a68041111..38c15d50ea 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -27,54 +27,49 @@ use audio::AppSounds;
 use auth::{AuthStore, AuthenticationInvalid, Plan};
 use camera::{CameraPreview, CameraWindowState};
 use cap_displays::{DisplayId, WindowId, bounds::LogicalBounds};
-use cap_editor::EditorInstance;
-use cap_editor::EditorState;
-use cap_project::RecordingMetaInner;
-use cap_project::XY;
+use cap_editor::{EditorInstance, EditorState};
 use cap_project::{
-    ProjectConfiguration, RecordingMeta, SharingMeta, StudioRecordingMeta, ZoomSegment,
+    ProjectConfiguration, RecordingMeta, RecordingMetaInner, SharingMeta, StudioRecordingMeta, XY,
+    ZoomSegment,
 };
-use cap_recording::feeds::DeviceOrModelID;
 use cap_recording::{
-    feeds::CameraFeed,
-    feeds::RawCameraFrame,
-    feeds::{AudioInputFeed, AudioInputSamplesSender},
+    feeds::{
+        self, CameraFeed, DeviceOrModelID, RawCameraFrame,
+        microphone::{self, MicrophoneFeed},
+    },
     sources::ScreenCaptureTarget,
 };
-use cap_rendering::ProjectRecordingsMeta;
-use cap_rendering::RenderedFrame;
+use cap_rendering::{ProjectRecordingsMeta, RenderedFrame};
 use clipboard_rs::common::RustImage;
 use clipboard_rs::{Clipboard, ClipboardContext};
-use editor_window::EditorInstances;
-use editor_window::WindowEditorInstance;
+use editor_window::{EditorInstances, WindowEditorInstance};
 use general_settings::GeneralSettingsStore;
+use kameo::{Actor, actor::ActorRef};
 use mp4::Mp4Reader;
 use notifications::NotificationType;
 use png::{ColorType, Encoder};
 use recording::InProgressRecording;
 use relative_path::RelativePathBuf;
-
-use scap::capturer::Capturer;
-use scap::frame::Frame;
-use scap::frame::VideoFrame;
+use scap::{
+    capturer::Capturer,
+    frame::{Frame, VideoFrame},
+};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use specta::Type;
-use std::collections::BTreeMap;
-use std::path::Path;
-use std::time::Duration;
 use std::{
+    collections::BTreeMap,
     fs::File,
     future::Future,
     io::{BufReader, BufWriter},
     marker::PhantomData,
-    path::PathBuf,
+    path::{Path, PathBuf},
     process::Command,
     str::FromStr,
     sync::Arc,
+    time::Duration,
 };
-use tauri::Window;
-use tauri::{AppHandle, Manager, State, WindowEvent};
+use tauri::{AppHandle, Manager, State, Window, WindowEvent};
 use tauri_plugin_deep_link::DeepLinkExt;
 use tauri_plugin_dialog::DialogExt;
 use tauri_plugin_global_shortcut::GlobalShortcutExt;
@@ -82,17 +77,14 @@ use tauri_plugin_notification::{NotificationExt, PermissionState};
 use tauri_plugin_opener::OpenerExt;
 use tauri_plugin_shell::ShellExt;
 use tauri_specta::Event;
-use tokio::sync::mpsc;
-use tokio::sync::{Mutex, RwLock};
-use tokio::time::timeout;
-use tracing::debug;
-use tracing::error;
-use tracing::trace;
+use tokio::{
+    sync::{Mutex, RwLock, mpsc},
+    time::timeout,
+};
+use tracing::{error, trace};
 use upload::{S3UploadMeta, create_or_get_video, upload_image, upload_video};
 use web_api::ManagerExt as WebManagerExt;
-use windows::EditorWindowIds;
-use windows::set_window_transparent;
-use windows::{CapWindowId, ShowCapWindow};
+use windows::{CapWindowId, EditorWindowIds, ShowCapWindow, set_window_transparent};
 
 use crate::upload::build_video_meta;
 
@@ -116,15 +108,13 @@ pub struct App {
     #[serde(skip)]
     camera_feed_initialization: Option<mpsc::Sender<()>>,
     #[serde(skip)]
-    mic_feed: Option<AudioInputFeed>,
-    #[serde(skip)]
-    mic_samples_tx: AudioInputSamplesSender,
-    #[serde(skip)]
     handle: AppHandle,
     #[serde(skip)]
     recording_state: RecordingState,
     #[serde(skip)]
     recording_logging_handle: LoggingHandle,
+    #[serde(skip)]
+    mic_feed: ActorRef<feeds::microphone::MicrophoneFeed>,
     server_url: String,
 }
 
@@ -227,27 +217,26 @@ impl App {
 #[tauri::command]
 #[specta::specta]
 async fn set_mic_input(state: MutableState<'_, App>, label: Option<String>) -> Result<(), String> {
-    let mut app = state.write().await;
+    let mic_feed = state.read().await.mic_feed.clone();
 
-    match (label, &mut app.mic_feed) {
-        (Some(label), None) => {
-            AudioInputFeed::init(&label)
-                .await
-                .map_err(|e| e.to_string())
-                .map(async |feed| {
-                    feed.add_sender(app.mic_samples_tx.clone()).await.unwrap();
-                    app.mic_feed = Some(feed);
-                })
-                .transpose_async()
+    match label {
+        None => {
+            mic_feed
+                .ask(microphone::RemoveInput)
                 .await
+                .map_err(|e| e.to_string())?;
         }
-        (Some(label), Some(feed)) => feed.switch_input(&label).await.map_err(|e| e.to_string()),
-        (None, _) => {
-            debug!("removing mic in set_start_recording_options");
-            app.mic_feed.take();
-            Ok(())
+        Some(label) => {
+            mic_feed
+                .ask(feeds::microphone::SetInput { label })
+                .await
+                .map_err(|e| e.to_string())?
+                .await
+                .map_err(|e| e.to_string())?;
         }
     }
+
+    Ok(())
 }
 
 #[tauri::command]
@@ -1119,7 +1108,7 @@ async fn list_audio_devices() -> Result<Vec<String>, ()> {
         return Ok(vec![]);
     }
 
-    Ok(AudioInputFeed::list_devices().keys().cloned().collect())
+    Ok(MicrophoneFeed::list().keys().cloned().collect())
 }
 
 #[derive(Serialize, Type, tauri_specta::Event, Debug, Clone)]
@@ -2024,7 +2013,28 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
 
     let (camera_tx, camera_ws_port, _shutdown) = camera_legacy::create_camera_preview_ws().await;
 
-    let (audio_input_tx, audio_input_rx) = AudioInputFeed::create_channel();
+    let (mic_samples_tx, mic_samples_rx) = flume::bounded(8);
+
+    let mic_feed = {
+        let (error_tx, error_rx) = flume::bounded(1);
+
+        let mic_feed = MicrophoneFeed::spawn(MicrophoneFeed::new(error_tx));
+
+        // TODO: make this part of a global actor one day
+        tokio::spawn(async move {
+            let Ok(err) = error_rx.recv_async().await else {
+                return;
+            };
+
+            error!("Mic feed actor error: {err}");
+        });
+
+        let _ = mic_feed
+            .ask(feeds::microphone::AddSender(mic_samples_tx))
+            .await;
+
+        mic_feed
+    };
 
     tauri::async_runtime::set(tokio::runtime::Handle::current());
 
@@ -2121,10 +2131,9 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
                     handle: app.clone(),
                     camera_feed: None,
                     camera_feed_initialization: None,
-                    mic_samples_tx: audio_input_tx,
-                    mic_feed: None,
                     recording_state: RecordingState::None,
                     recording_logging_handle,
+                    mic_feed,
                     server_url: GeneralSettingsStore::get(&app)
                         .ok()
                         .flatten()
@@ -2173,7 +2182,7 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
                 }
             });
 
-            audio_meter::spawn_event_emitter(app.clone(), audio_input_rx);
+            audio_meter::spawn_event_emitter(app.clone(), mic_samples_rx);
 
             tray::create_tray(&app).unwrap();
 
@@ -2213,7 +2222,8 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
                                     let app_state = &mut *state.write().await;
 
                                     if !app_state.is_recording_active_or_pending() {
-                                        app_state.mic_feed.take();
+                                        let _ =
+                                            app_state.mic_feed.ask(microphone::RemoveInput).await;
                                         app_state.camera_feed.take();
 
                                         if let Some(camera) = CapWindowId::Camera.get(&app) {
@@ -2422,28 +2432,6 @@ trait EventExt: tauri_specta::Event {
 
 impl<T: tauri_specta::Event> EventExt for T {}
 
-trait TransposeAsync {
-    type Output;
-
-    fn transpose_async(self) -> impl Future<Output = Self::Output>
-    where
-        Self: Sized;
-}
-
-impl<F: Future<Output = T>, T, E> TransposeAsync for Result<F, E> {
-    type Output = Result<T, E>;
-
-    async fn transpose_async(self) -> Self::Output
-    where
-        Self: Sized,
-    {
-        match self {
-            Ok(f) => Ok(f.await),
-            Err(e) => Err(e),
-        }
-    }
-}
-
 fn open_project_from_path(path: &Path, app: AppHandle) -> Result<(), String> {
     let meta = RecordingMeta::load_for_project(path).map_err(|v| v.to_string())?;
 
diff --git a/apps/desktop/src-tauri/src/recording.rs b/apps/desktop/src-tauri/src/recording.rs
index 918d156bd1..b9892b217f 100644
--- a/apps/desktop/src-tauri/src/recording.rs
+++ b/apps/desktop/src-tauri/src/recording.rs
@@ -6,7 +6,7 @@ use cap_project::{
 };
 use cap_recording::{
     CompletedStudioRecording, RecordingError, RecordingMode, StudioRecordingHandle,
-    feeds::CameraFeed,
+    feeds::{CameraFeed, microphone},
     instant_recording::{CompletedInstantRecording, InstantRecordingHandle},
     sources::{CaptureDisplay, CaptureWindow, ScreenCaptureTarget, screen_capture},
 };
@@ -348,15 +348,21 @@ pub async fn start_recording(
         spawn_actor({
             let state_mtx = Arc::clone(&state_mtx);
             let general_settings = general_settings.cloned();
-            let capture_target = inputs.capture_target.clone();
             async move {
                 fail!("recording::spawn_actor");
                 let mut state = state_mtx.write().await;
 
+                use kameo::error::SendError;
+                let mic_feed = match state.mic_feed.ask(microphone::Lock).await {
+                    Ok(lock) => Some(Arc::new(lock)),
+                    Err(SendError::HandlerError(microphone::LockFeedError::NoInput)) => None,
+                    Err(e) => return Err(e.to_string()),
+                };
+
                 let base_inputs = cap_recording::RecordingBaseInputs {
-                    capture_target,
+                    capture_target: inputs.capture_target.clone(),
                     capture_system_audio: inputs.capture_system_audio,
-                    mic_feed: &state.mic_feed,
+                    mic_feed,
                 };
 
                 let (actor, actor_done_rx) = match inputs.mode {
@@ -647,7 +653,7 @@ async fn handle_recording_end(
             let _ = v.close();
         }
         app.camera_feed.take();
-        app.mic_feed.take();
+        let _ = app.mic_feed.ask(microphone::RemoveInput).await;
     }
 
     CurrentRecordingChanged.emit(&handle).ok();
diff --git a/apps/desktop/src/routes/(window-chrome)/(main).tsx b/apps/desktop/src/routes/(window-chrome)/(main).tsx
index 30bf74ca9c..f250974dfe 100644
--- a/apps/desktop/src/routes/(window-chrome)/(main).tsx
+++ b/apps/desktop/src/routes/(window-chrome)/(main).tsx
@@ -176,10 +176,6 @@ function Page() {
 		micName: () => mics.data?.find((name) => name === rawOptions.micName),
 	};
 
-	createEffect(() => {
-		console.log(_windows());
-	});
-
 	// if target is window and no windows are available, switch to screen capture
 	createEffect(() => {
 		const screen = _screens()?.[0];
@@ -257,7 +253,8 @@ function Page() {
 	const setCamera = createCameraMutation();
 
 	onMount(() => {
-		if (rawOptions.cameraID) setCamera.mutate(rawOptions.cameraID);
+		if (rawOptions.micName) commands.setMicInput(rawOptions.micName);
+		if (rawOptions.cameraID) setCamera.rawMutate(rawOptions.cameraID);
 	});
 
 	return (
@@ -821,7 +818,6 @@ function MicrophoneSelect(props: {
 	const currentRecording = createCurrentRecordingQuery();
 
 	const [dbs, setDbs] = createSignal<number | undefined>();
-	const [isInitialized, setIsInitialized] = createSignal(false);
 
 	const requestPermission = useRequestPermission();
 
@@ -852,14 +848,6 @@ function MicrophoneSelect(props: {
 	const audioLevel = () =>
 		(1 - Math.max((dbs() ?? 0) + DB_SCALE, 0) / DB_SCALE) ** 0.5;
 
-	// Initialize audio input if needed - only once when component mounts
-	onMount(() => {
-		if (!props.value || !permissionGranted() || isInitialized()) return;
-
-		setIsInitialized(true);
-		handleMicrophoneChange({ name: props.value });
-	});
-
 	return (
 		<div class="flex flex-col gap-[0.25rem] items-stretch text-[--text-primary]">
 			<button
@@ -893,7 +881,7 @@ function MicrophoneSelect(props: {
 						});
 				}}
 			>
-				<Show when={dbs()}>
+				<Show when={props.value !== null && dbs()}>
 					{(_) => (
 						<div
 							class="bg-blue-100 opacity-50 left-0 inset-y-0 absolute -z-10 transition-[right] duration-100"
diff --git a/apps/desktop/src/utils/queries.ts b/apps/desktop/src/utils/queries.ts
index 2e0fa67f19..ceafcc1cb5 100644
--- a/apps/desktop/src/utils/queries.ts
+++ b/apps/desktop/src/utils/queries.ts
@@ -1,9 +1,9 @@
 import { createEventListener } from "@solid-primitives/event-listener";
 import { makePersisted } from "@solid-primitives/storage";
 import {
-	createMutation,
 	createQuery,
 	queryOptions,
+	useMutation,
 	useQuery,
 } from "@tanstack/solid-query";
 import { getCurrentWindow } from "@tauri-apps/api/window";
@@ -152,26 +152,36 @@ export function createLicenseQuery() {
 export function createCameraMutation() {
 	const { setOptions, rawOptions } = useRecordingOptions();
 
-	const setCameraInput = createMutation(() => ({
-		mutationFn: async (model: DeviceOrModelID | null) => {
-			const before = rawOptions.cameraID ? { ...rawOptions.cameraID } : null;
-			setOptions("cameraID", reconcile(model));
-			if (model) {
-				await commands.showWindow("Camera");
-				getCurrentWindow().setFocus();
-			}
-
-			await commands.setCameraInput(model).catch(async (e) => {
-				if (JSON.stringify(before) === JSON.stringify(model) || !before) {
-					setOptions("cameraID", null);
-				} else setOptions("cameraID", reconcile(before));
-
-				throw e;
-			});
-		},
+	const rawMutate = async (model: DeviceOrModelID | null) => {
+		const before = rawOptions.cameraID ? { ...rawOptions.cameraID } : null;
+		setOptions("cameraID", reconcile(model));
+		if (model) {
+			await commands.showWindow("Camera");
+			getCurrentWindow().setFocus();
+		}
+
+		await commands.setCameraInput(model).catch(async (e) => {
+			if (JSON.stringify(before) === JSON.stringify(model) || !before) {
+				setOptions("cameraID", null);
+			} else setOptions("cameraID", reconcile(before));
+
+			throw e;
+		});
+	};
+
+	const setCameraInput = useMutation(() => ({
+		mutationFn: rawMutate,
 	}));
 
-	return setCameraInput;
+	return new Proxy(
+		setCameraInput as typeof setCameraInput & { rawMutate: typeof rawMutate },
+		{
+			get(target, key) {
+				if (key === "rawMutate") return rawMutate;
+				return Reflect.get(target, key);
+			},
+		},
+	);
 }
 
 export function createCustomDomainQuery() {
diff --git a/crates/cpal-ffmpeg/Cargo.toml b/crates/cpal-ffmpeg/Cargo.toml
new file mode 100644
index 0000000000..4ea431bd53
--- /dev/null
+++ b/crates/cpal-ffmpeg/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "cap-cpal-ffmpeg"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+cpal.workspace = true
+ffmpeg.workspace = true
+
+[lints]
+workspace = true
diff --git a/crates/cpal-ffmpeg/src/lib.rs b/crates/cpal-ffmpeg/src/lib.rs
new file mode 100644
index 0000000000..0074e82591
--- /dev/null
+++ b/crates/cpal-ffmpeg/src/lib.rs
@@ -0,0 +1,81 @@
+use cpal::{SampleFormat, StreamConfig};
+use ffmpeg::format::{Sample, sample};
+
+pub trait DataExt {
+    fn as_ffmpeg(&self, config: &StreamConfig) -> ffmpeg::frame::Audio;
+}
+
+impl DataExt for ::cpal::Data {
+    fn as_ffmpeg(&self, config: &StreamConfig) -> ffmpeg::frame::Audio {
+        let format_typ = sample::Type::Packed;
+
+        let sample_size = self.sample_format().sample_size();
+        let sample_count = self.bytes().len() / (sample_size * config.channels as usize);
+
+        let mut ffmpeg_frame = ffmpeg::frame::Audio::new(
+            match self.sample_format() {
+                SampleFormat::F32 => Sample::F32(format_typ),
+                SampleFormat::F64 => Sample::F64(format_typ),
+                SampleFormat::I16 => Sample::I16(format_typ),
+                SampleFormat::I32 => Sample::I32(format_typ),
+                SampleFormat::U8 => Sample::U8(format_typ),
+                _ => panic!("Unsupported sample format"),
+            },
+            sample_count,
+            ffmpeg::ChannelLayout::default(config.channels as i32),
+        );
+
+        if matches!(format_typ, sample::Type::Planar) {
+            for i in 0..config.channels {
+                let plane_size = sample_count * sample_size as usize;
+                let base = (i as usize) * plane_size;
+
+                ffmpeg_frame
+                    .plane_data_mut(i as usize)
+                    .copy_from_slice(&self.bytes()[base..base + plane_size]);
+            }
+        } else {
+            ffmpeg_frame.data_mut(0).copy_from_slice(self.bytes());
+        }
+
+        ffmpeg_frame.set_rate(config.sample_rate.0);
+
+        ffmpeg_frame
+    }
+}
+
+pub trait PlanarData {
+    fn plane_data(&self, index: usize) -> &[u8];
+
+    fn plane_data_mut(&mut self, index: usize) -> &mut [u8];
+}
+
+impl PlanarData for ffmpeg::frame::Audio {
+    #[inline]
+    fn plane_data(&self, index: usize) -> &[u8] {
+        if index >= self.planes() {
+            panic!("out of bounds");
+        }
+
+        unsafe {
+            std::slice::from_raw_parts(
+                (*self.as_ptr()).data[index],
+                (*self.as_ptr()).linesize[0] as usize,
+            )
+        }
+    }
+
+    #[inline]
+    fn plane_data_mut(&mut self, index: usize) -> &mut [u8] {
+        if index >= self.planes() {
+            panic!("out of bounds");
+        }
+
+        unsafe {
+            std::slice::from_raw_parts_mut(
+                (*self.as_mut_ptr()).data[index],
+                (*self.as_ptr()).linesize[0] as usize,
+            )
+        }
+    }
+}
diff --git a/crates/media/Cargo.toml b/crates/media/Cargo.toml
index 4e6d7fbdf5..80951311d9 100644
--- a/crates/media/Cargo.toml
+++ b/crates/media/Cargo.toml
@@ -17,6 +17,7 @@ cap-flags = { path = "../flags" }
 cap-audio = { path = "../audio" }
 cap-camera = { path = "../camera", features = ["specta", "serde"] }
 cap-camera-ffmpeg = { path = "../camera-ffmpeg" }
+cap-cpal-ffmpeg = { path = "../cpal-ffmpeg" }
 cap-displays = { path = "../displays" }
 cap-fail = { path = "../fail" }
 cap-media-encoders = { path = "../media-encoders" }
diff --git a/crates/recording/Cargo.toml b/crates/recording/Cargo.toml
index 25b5cf7e1f..6ac1308461 100644
--- a/crates/recording/Cargo.toml
+++ b/crates/recording/Cargo.toml
@@ -45,6 +45,7 @@ cpal.workspace = true
 indexmap = "2.10.0"
 kameo = "0.17.2"
 inquire = "0.7.5"
+replace_with = "0.1.8"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 screencapturekit = "0.3.5"
diff --git a/crates/recording/src/capture_pipeline.rs b/crates/recording/src/capture_pipeline.rs
index ec09554fd2..25962d1563 100644
--- a/crates/recording/src/capture_pipeline.rs
+++ b/crates/recording/src/capture_pipeline.rs
@@ -11,7 +11,7 @@ use std::{
 
 use crate::{
     RecordingError,
-    feeds::AudioInputFeed,
+    feeds::microphone::MicrophoneFeedLock,
     pipeline::builder::PipelineBuilder,
     sources::{
         AudioInputSource, AudioMixer, ScreenCaptureFormat, ScreenCaptureSource,
@@ -37,7 +37,7 @@ pub trait MakeCapturePipeline: ScreenCaptureFormat + std::fmt::Debug + 'static {
             ScreenCaptureSource<Self>,
             flume::Receiver<(Self::VideoFormat, f64)>,
         ),
-        audio: Option<&AudioInputFeed>,
+        audio: Option<Arc<MicrophoneFeedLock>>,
         system_audio: Option<(Receiver<(ffmpeg::frame::Audio, f64)>, AudioInfo)>,
         output_path: PathBuf,
         pause_flag: Arc<AtomicBool>,
@@ -112,7 +112,7 @@ impl MakeCapturePipeline for screen_capture::CMSampleBufferCapture {
             ScreenCaptureSource<Self>,
             flume::Receiver<(Self::VideoFormat, f64)>,
         ),
-        audio: Option<&AudioInputFeed>,
+        audio: Option<Arc<MicrophoneFeedLock>>,
         system_audio: Option<(Receiver<(ffmpeg::frame::Audio, f64)>, AudioInfo)>,
         output_path: PathBuf,
         pause_flag: Arc<AtomicBool>,
@@ -125,7 +125,7 @@ impl MakeCapturePipeline for screen_capture::CMSampleBufferCapture {
         }
 
         if let Some(audio) = audio {
-            let sink = audio_mixer.sink(audio.audio_info());
+            let sink = audio_mixer.sink(*audio.audio_info());
             let source = AudioInputSource::init(audio, sink.tx, SystemTime::now());
 
             builder.spawn_source("microphone_capture", source);
@@ -276,7 +276,7 @@ impl MakeCapturePipeline for screen_capture::AVFrameCapture {
             ScreenCaptureSource<Self>,
             flume::Receiver<(Self::VideoFormat, f64)>,
         ),
-        audio: Option<&AudioInputFeed>,
+        audio: Option<Arc<MicrophoneFeedLock>>,
         system_audio: Option<(Receiver<(ffmpeg::frame::Audio, f64)>, AudioInfo)>,
         output_path: PathBuf,
         _pause_flag: Arc<AtomicBool>,
@@ -294,7 +294,7 @@ impl MakeCapturePipeline for screen_capture::AVFrameCapture {
         }
 
         if let Some(audio) = audio {
-            let sink = audio_mixer.sink(audio.audio_info());
+            let sink = audio_mixer.sink(*audio.audio_info());
             let source = AudioInputSource::init(audio, sink.tx, SystemTime::now());
 
             builder.spawn_source("microphone_capture", source);
diff --git a/crates/recording/src/feeds/audio_input.rs b/crates/recording/src/feeds/audio_input.rs
deleted file mode 100644
index d74378b384..0000000000
--- a/crates/recording/src/feeds/audio_input.rs
+++ /dev/null
@@ -1,350 +0,0 @@
-use cap_fail::fail_err;
-use cap_media_info::{AudioInfo, ffmpeg_sample_format_for};
-use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
-use cpal::{Device, InputCallbackInfo, SampleFormat, StreamConfig, SupportedStreamConfig};
-use flume::{Receiver, Sender, TrySendError};
-use indexmap::IndexMap;
-use tracing::{debug, error, info, trace, warn};
-
-use crate::MediaError;
-
-#[derive(Clone)]
-pub struct AudioInputSamples {
-    pub data: Vec<u8>,
-    pub format: SampleFormat,
-    pub info: InputCallbackInfo,
-}
-
-pub enum AudioInputControl {
-    Switch(String, Sender<Result<SupportedStreamConfig, MediaError>>),
-    AttachSender(AudioInputSamplesSender),
-    Shutdown,
-}
-
-pub struct AudioInputConnection {
-    control: Sender<AudioInputControl>,
-}
-
-impl AudioInputConnection {
-    pub fn attach(&self) -> Receiver<AudioInputSamples> {
-        let (sender, receiver) = flume::bounded(5);
-        self.control
-            .send(AudioInputControl::AttachSender(sender))
-            .unwrap();
-
-        receiver
-    }
-}
-
-pub type AudioInputSamplesSender = Sender<AudioInputSamples>;
-pub type AudioInputSamplesReceiver = Receiver<AudioInputSamples>;
-
-pub type AudioInputDeviceMap = IndexMap<String, (Device, SupportedStreamConfig)>;
-
-pub const MAX_AUDIO_CHANNELS: u16 = 2;
-
-#[derive(Clone)]
-pub struct AudioInputFeed {
-    pub control_tx: Sender<AudioInputControl>,
-    audio_info: AudioInfo,
-    // rx: Receiver<AudioInputSamples>,
-}
-
-impl AudioInputFeed {
-    pub fn create_channel() -> (AudioInputSamplesSender, AudioInputSamplesReceiver) {
-        flume::bounded(60)
-    }
-
-    pub async fn init(selected_input: &str) -> Result<Self, MediaError> {
-        trace!("Initializing audio input feed with device");
-        debug!(selected_input);
-
-        fail_err!(
-            "media::feeds::audio_input::init",
-            MediaError::Any("".into())
-        );
-
-        let (device, config) = Self::list_devices()
-            .swap_remove_entry(selected_input)
-            .map(|(device_name, (device, config))| {
-                info!(
-                    "Using audio device: {} with config: {:?}",
-                    device_name, config
-                );
-                (device, config)
-            })
-            .ok_or_else(|| {
-                error!("Failed to find audio device: {}", selected_input);
-                MediaError::DeviceUnreachable(selected_input.to_string())
-            })?;
-
-        let audio_info = AudioInfo::from_stream_config(&config);
-
-        debug!("Created audio info: {:?}", audio_info);
-        let (control_tx, control_rx) = flume::bounded(1);
-
-        std::thread::spawn(|| start_capturing(device, config, control_rx));
-        info!("Started audio capture thread");
-
-        Ok(Self {
-            control_tx,
-            audio_info,
-        })
-    }
-
-    pub fn list_devices() -> AudioInputDeviceMap {
-        let host = cpal::default_host();
-        let mut device_map = IndexMap::new();
-
-        let get_usable_device = |device: Device| {
-            device
-                .supported_input_configs()
-                .map_err(|error| {
-                    error!(
-                        "Error getting supported input configs for device: {}",
-                        error
-                    );
-                    error
-                })
-                .ok()
-                .and_then(|configs| {
-                    let mut configs = configs.collect::<Vec<_>>();
-                    configs.sort_by(|a, b| {
-                        b.sample_format()
-                            .sample_size()
-                            .cmp(&a.sample_format().sample_size())
-                            .then(b.max_sample_rate().cmp(&a.max_sample_rate()))
-                    });
-                    configs
-                        .into_iter()
-                        .filter(|c| {
-                            c.min_sample_rate().0 <= 48000 && c.max_sample_rate().0 <= 48000
-                        })
-                        .find(|c| ffmpeg_sample_format_for(c.sample_format()).is_some())
-                })
-                .and_then(|config| {
-                    device
-                        .name()
-                        .ok()
-                        .map(|name| (name, device, config.with_max_sample_rate()))
-                })
-        };
-
-        if let Some((name, device, config)) =
-            host.default_input_device().and_then(get_usable_device)
-        {
-            device_map.insert(name, (device, config));
-        } else {
-            warn!("No default input device found or it's not usable");
-        }
-
-        match host.input_devices() {
-            Ok(devices) => {
-                for (name, device, config) in devices.filter_map(get_usable_device) {
-                    device_map.entry(name).or_insert((device, config));
-                }
-            }
-            Err(error) => {
-                error!("Could not access audio input devices: {}", error);
-            }
-        }
-
-        device_map
-    }
-
-    pub async fn switch_input(&mut self, name: &str) -> Result<(), MediaError> {
-        fail_err!(
-            "media::feeds::audio_input::switch_input",
-            MediaError::Any("".into())
-        );
-
-        let (tx, rx) = flume::bounded(1);
-
-        self.control_tx
-            .send_async(AudioInputControl::Switch(name.to_string(), tx))
-            .await
-            .map_err(|error| {
-                eprintln!("Error while switching audio input: {error}");
-                MediaError::TaskLaunch("Failed to switch audio input".into())
-            })?;
-
-        let config = rx.recv_async().await.map_err(|error| {
-            eprintln!("Error while switching audio input: {error}");
-            MediaError::TaskLaunch("Failed to switch audio input".into())
-        })??;
-
-        self.audio_info = AudioInfo::from_stream_config(&config);
-
-        Ok(())
-    }
-
-    pub async fn add_sender(&self, sender: AudioInputSamplesSender) -> Result<(), MediaError> {
-        self.control_tx
-            .send_async(AudioInputControl::AttachSender(sender))
-            .await
-            .map_err(|error| {
-                eprintln!("Error while attaching audio input sender: {error}");
-                MediaError::TaskLaunch("Failed to attach audio input sender".into())
-            })?;
-
-        Ok(())
-    }
-
-    pub fn audio_info(&self) -> AudioInfo {
-        self.audio_info
-    }
-
-    pub fn create_connection(&self) -> AudioInputConnection {
-        AudioInputConnection {
-            control: self.control_tx.clone(),
-        }
-    }
-}
-
-fn start_capturing(
-    mut device: Device,
-    mut config: SupportedStreamConfig,
-    control: Receiver<AudioInputControl>,
-) {
-    debug!(
-        "Starting audio capture with device: {:?}, config: {:?}",
-        device.name(),
-        config
-    );
-    let mut senders: Vec<AudioInputSamplesSender> = vec![];
-
-    loop {
-        let (tx, rx) = flume::bounded(4);
-        debug!("Building input stream with config: {:?}", config);
-
-        let stream_config: StreamConfig = config.clone().into();
-        let stream = match device.build_input_stream_raw(
-            &stream_config,
-            config.sample_format(),
-            move |data, info| {
-                if let Err(e) = tx.send(AudioInputSamples {
-                    data: data.bytes().to_vec(),
-                    format: data.sample_format(),
-                    info: info.clone(),
-                }) {
-                    error!("Failed to send audio samples: {}", e);
-                }
-            },
-            |e| {
-                error!("Error in audio input stream: {}", e);
-            },
-            None,
-        ) {
-            Ok(stream) => {
-                info!("Successfully built audio input stream");
-                stream
-            }
-            Err(err) => {
-                error!("Failed to build audio input stream: {}", err);
-                // Sleep briefly to avoid tight error loop
-                std::thread::sleep(std::time::Duration::from_secs(1));
-                continue;
-            }
-        };
-
-        // Try to play the stream
-        if let Err(e) = stream.play() {
-            error!("Failed to start audio stream playback: {}", e);
-            continue;
-        }
-        info!("Audio stream playback started");
-
-        loop {
-            match control.try_recv() {
-                Ok(AudioInputControl::Switch(name, response)) => {
-                    if device.name().unwrap() == name {
-                        response.send(Ok(config.clone())).unwrap();
-                        continue;
-                    }
-
-                    debug!("Switching audio device to: {}", name);
-                    // list_devices hangs if the stream isn't dropped
-                    drop(stream);
-                    let Some(items) = AudioInputFeed::list_devices().swap_remove_entry(&name).map(
-                        |(device_name, (device, config))| {
-                            info!(
-                                "Switched to audio device: {} with config: {:?}",
-                                device_name, config
-                            );
-                            (device, config)
-                        },
-                    ) else {
-                        error!("Failed to find audio device: {}", name);
-                        response
-                            .send(Err(MediaError::DeviceUnreachable(name)))
-                            .unwrap();
-                        break;
-                    };
-
-                    device = items.0;
-                    config = items.1;
-
-                    response.send(Ok(config.clone())).unwrap();
-                    break;
-                }
-                Ok(AudioInputControl::Shutdown) => {
-                    debug!("Received shutdown signal for audio capture");
-                    return;
-                }
-                Ok(AudioInputControl::AttachSender(sender)) => {
-                    senders.push(sender);
-                    info!("New audio sender attached");
-                }
-                Err(flume::TryRecvError::Disconnected) => {
-                    warn!("Control receiver is unreachable! Shutting down audio capture");
-                    return;
-                }
-                Err(flume::TryRecvError::Empty) => {
-                    // No signal received, nothing to do
-                }
-            }
-
-            match rx.recv() {
-                Ok(mut data) => {
-                    let mut to_remove = vec![];
-
-                    if config.channels() > MAX_AUDIO_CHANNELS {
-                        let mut new_data = Vec::with_capacity(
-                            MAX_AUDIO_CHANNELS as usize
-                                * (data.data.len() / config.channels() as usize),
-                        );
-
-                        let sample_size = data.format.sample_size();
-
-                        for sample in data.data.chunks(sample_size * config.channels() as usize) {
-                            new_data.extend_from_slice(
-                                &sample[0..sample_size * MAX_AUDIO_CHANNELS as usize],
-                            );
-                        }
-
-                        data.data = new_data;
-                    }
-
-                    for (i, sender) in senders.iter().enumerate() {
-                        if let Err(TrySendError::Disconnected(_)) = sender.try_send(data.clone()) {
-                            warn!("Audio sender {} disconnected, will be removed", i);
-                            to_remove.push(i);
-                        };
-                    }
-
-                    if !to_remove.is_empty() {
-                        debug!("Removing {} disconnected audio senders", to_remove.len());
-                        for i in to_remove.into_iter().rev() {
-                            senders.swap_remove(i);
-                        }
-                    }
-                }
-                Err(error) => {
-                    error!("Failed to capture audio samples: {:?}", error);
-                    // Break inner loop to recreate the stream
-                    break;
-                }
-            }
-        }
-    }
-}
diff --git a/crates/recording/src/feeds/microphone.rs b/crates/recording/src/feeds/microphone.rs
new file mode 100644
index 0000000000..07f20ceec8
--- /dev/null
+++ b/crates/recording/src/feeds/microphone.rs
@@ -0,0 +1,510 @@
+use cap_media_info::{AudioInfo, ffmpeg_sample_format_for};
+use cpal::{
+    Device, InputCallbackInfo, SampleFormat, StreamError, SupportedStreamConfig,
+    traits::{DeviceTrait, HostTrait, StreamTrait},
+};
+use flume::TrySendError;
+use futures::{FutureExt, channel::oneshot, future::BoxFuture};
+use indexmap::IndexMap;
+use kameo::prelude::*;
+use replace_with::replace_with_or_abort;
+use std::{
+    ops::Deref,
+    sync::mpsc::{self, SyncSender},
+};
+use tracing::{debug, error, info, trace, warn};
+
+pub type MicrophonesMap = IndexMap<String, (Device, SupportedStreamConfig)>;
+
+#[derive(Clone)]
+pub struct MicrophoneSamples {
+    pub data: Vec<u8>,
+    pub format: SampleFormat,
+    pub info: InputCallbackInfo,
+}
+
+#[derive(Actor)]
+pub struct MicrophoneFeed {
+    input_id_counter: u32,
+    state: State,
+    senders: Vec<flume::Sender<MicrophoneSamples>>,
+    error_sender: flume::Sender<StreamError>,
+}
+
+enum State {
+    Open(OpenState),
+    Locked { inner: AttachedState },
+}
+
+impl State {
+    fn try_as_open(&mut self) -> Result<&mut OpenState, FeedLockedError> {
+        if let Self::Open(open_state) = self {
+            Ok(open_state)
+        } else {
+            Err(FeedLockedError)
+        }
+    }
+}
+
+struct OpenState {
+    connecting: Option<ConnectingState>,
+    attached: Option<AttachedState>,
+}
+
+impl OpenState {
+    fn handle_input_connected(&mut self, data: InputConnected) {
+        if let Some(connecting) = &self.connecting
+            && data.id == connecting.id
+        {
+            self.attached = Some(AttachedState {
+                id: data.id,
+                config: data.config.clone(),
+                done_tx: data.done_tx,
+            });
+            self.connecting = None;
+        }
+    }
+}
+
+struct ConnectingState {
+    id: u32,
+    ready: BoxFuture<'static, Result<InputConnected, SetInputError>>,
+}
+
+struct AttachedState {
+    id: u32,
+    config: SupportedStreamConfig,
+    done_tx: mpsc::SyncSender<()>,
+}
+
+impl MicrophoneFeed {
+    pub fn new(error_sender: flume::Sender<StreamError>) -> Self {
+        Self {
+            input_id_counter: 0,
+            state: State::Open(OpenState {
+                connecting: None,
+                attached: None,
+            }),
+            senders: Vec::new(),
+            error_sender,
+        }
+    }
+
+    pub fn list() -> MicrophonesMap {
+        let host = cpal::default_host();
+        let mut device_map = IndexMap::new();
+
+        let get_usable_device = |device: Device| {
+            device
+                .supported_input_configs()
+                .map_err(|error| {
+                    error!(
+                        "Error getting supported input configs for device: {}",
+                        error
+                    );
+                    error
+                })
+                .ok()
+                .and_then(|configs| {
+                    let mut configs = configs.collect::<Vec<_>>();
+                    configs.sort_by(|a, b| {
+                        b.sample_format()
+                            .sample_size()
+                            .cmp(&a.sample_format().sample_size())
+                            .then(b.max_sample_rate().cmp(&a.max_sample_rate()))
+                    });
+                    configs
+                        .into_iter()
+                        .filter(|c| {
+                            c.min_sample_rate().0 <= 48000 && c.max_sample_rate().0 <= 48000
+                        })
+                        .find(|c| ffmpeg_sample_format_for(c.sample_format()).is_some())
+                })
+                .and_then(|config| {
+                    device
+                        .name()
+                        .ok()
+                        .map(|name| (name, device, config.with_max_sample_rate()))
+                })
+        };
+
+        if let Some((name, device, config)) =
+            host.default_input_device().and_then(get_usable_device)
+        {
+            device_map.insert(name, (device, config));
+        } else {
+            warn!("No default input device found or it's not usable");
+        }
+
+        match host.input_devices() {
+            Ok(devices) => {
+                for (name, device, config) in devices.filter_map(get_usable_device) {
+                    device_map.entry(name).or_insert((device, config));
+                }
+            }
+            Err(error) => {
+                error!("Could not access audio input devices: {}", error);
+            }
+        }
+
+        device_map
+    }
+}
+
+#[derive(Reply)]
+pub struct MicrophoneFeedLock {
+    actor: ActorRef<MicrophoneFeed>,
+    config: SupportedStreamConfig,
+    audio_info: AudioInfo,
+    lock_tx: Recipient<Unlock>,
+}
+
+impl MicrophoneFeedLock {
+    pub fn config(&self) -> &SupportedStreamConfig {
+        &self.config
+    }
+
+    pub fn audio_info(&self) -> &AudioInfo {
+        &self.audio_info
+    }
+}
+
+impl Deref for MicrophoneFeedLock {
+    type Target = ActorRef<MicrophoneFeed>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.actor
+    }
+}
+
+impl Drop for MicrophoneFeedLock {
+    fn drop(&mut self) {
+        let _ = self.lock_tx.tell(Unlock).blocking_send();
+    }
+}
+
+// Public Requests
+
+pub struct SetInput {
+    pub label: String,
+}
+
+pub struct RemoveInput;
+
+pub struct AddSender(pub flume::Sender<MicrophoneSamples>);
+
+pub struct Lock;
+
+// Private Events
+
+struct InputConnected {
+    id: u32,
+    config: SupportedStreamConfig,
+    done_tx: SyncSender<()>,
+}
+
+struct InputConnectFailed {
+    id: u32,
+}
+
+struct Unlock;
+
+// Impls
+
+#[derive(Debug, Clone, Copy, thiserror::Error)]
+#[error("FeedLocked")]
+pub struct FeedLockedError;
+
+#[derive(Clone, Debug, thiserror::Error)]
+pub enum SetInputError {
+    #[error(transparent)]
+    Locked(#[from] FeedLockedError),
+    #[error("DeviceNotFound")]
+    DeviceNotFound,
+    #[error("BuildStreamCrashed")]
+    BuildStreamCrashed,
+    // we use strings for these as the cpal errors aren't Clone
+    #[error("BuildStream: {0}")]
+    BuildStream(String),
+    #[error("PlayStream: {0}")]
+    PlayStream(String),
+}
+
+impl Message<SetInput> for MicrophoneFeed {
+    type Reply =
+        Result<BoxFuture<'static, Result<SupportedStreamConfig, SetInputError>>, SetInputError>;
+
+    async fn handle(&mut self, msg: SetInput, ctx: &mut Context<Self, Self::Reply>) -> Self::Reply {
+        trace!("MicrophoneFeed.SetInput('{}')", &msg.label);
+
+        let state = self.state.try_as_open()?;
+
+        let id = self.input_id_counter;
+        self.input_id_counter += 1;
+
+        let Some((device, config)) = Self::list().swap_remove(&msg.label) else {
+            return Err(SetInputError::DeviceNotFound);
+        };
+
+        let sample_format = config.sample_format();
+
+        let (ready_tx, ready_rx) = oneshot::channel();
+        let (done_tx, done_rx) = mpsc::sync_channel(0);
+
+        let actor_ref = ctx.actor_ref();
+        let ready = {
+            let config = config.clone();
+            ready_rx
+                .map(|v| {
+                    v.map_err(|_| SetInputError::BuildStreamCrashed)
+                        .map(|_| config)
+                })
+                .shared()
+        };
+        let error_sender = self.error_sender.clone();
+
+        state.connecting = Some(ConnectingState {
+            id,
+            ready: {
+                let done_tx = done_tx.clone();
+                ready
+                    .clone()
+                    .map(move |v| {
+                        v.map(|config| InputConnected {
+                            id,
+                            config,
+                            done_tx,
+                        })
+                    })
+                    .boxed()
+            },
+        });
+
+        std::thread::spawn({
+            let config = config.clone();
+            move || {
+                let stream = match device.build_input_stream_raw(
+                    &config.into(),
+                    sample_format,
+                    {
+                        let actor_ref = actor_ref.clone();
+                        move |data, info| {
+                            let _ = actor_ref
+                                .tell(MicrophoneSamples {
+                                    data: data.bytes().to_vec(),
+                                    format: data.sample_format(),
+                                    info: info.clone(),
+                                })
+                                .try_send();
+                        }
+                    },
+                    move |e| {
+                        error!("Microphone stream error: {e}");
+
+                        let _ = error_sender.send(e).is_err();
+                        actor_ref.kill();
+                    },
+                    None,
+                ) {
+                    Ok(stream) => stream,
+                    Err(e) => {
+                        let _ = ready_tx.send(Err(SetInputError::BuildStream(e.to_string())));
+                        return;
+                    }
+                };
+
+                if let Err(e) = stream.play() {
+                    let _ = ready_tx.send(Err(SetInputError::PlayStream(e.to_string())));
+                    return;
+                }
+
+                let _ = ready_tx.send(Ok(()));
+
+                match done_rx.recv() {
+                    Ok(_) => {
+                        info!("Microphone actor shut down, ending stream");
+                    }
+                    Err(_) => {
+                        info!("Microphone actor unreachable, ending stream");
+                    }
+                }
+            }
+        });
+
+        tokio::spawn({
+            let ready = ready.clone();
+            let actor = ctx.actor_ref();
+            async move {
+                match ready.await {
+                    Ok(config) => {
+                        let _ = actor
+                            .tell(InputConnected {
+                                id,
+                                config,
+                                done_tx,
+                            })
+                            .await;
+                    }
+                    Err(_) => {
+                        let _ = actor.tell(InputConnectFailed { id }).await;
+                    }
+                }
+            }
+        });
+
+        Ok(ready.boxed())
+    }
+}
+
+impl Message<RemoveInput> for MicrophoneFeed {
+    type Reply = Result<(), FeedLockedError>;
+
+    async fn handle(&mut self, _: RemoveInput, _: &mut Context<Self, Self::Reply>) -> Self::Reply {
+        trace!("MicrophoneFeed.RemoveInput");
+
+        let state = self.state.try_as_open()?;
+
+        state.connecting = None;
+
+        if let Some(AttachedState { done_tx, .. }) = state.attached.take() {
+            let _ = done_tx.send(());
+        }
+
+        Ok(())
+    }
+}
+
+impl Message<AddSender> for MicrophoneFeed {
+    type Reply = ();
+
+    async fn handle(&mut self, msg: AddSender, _: &mut Context<Self, Self::Reply>) -> Self::Reply {
+        self.senders.push(msg.0);
+    }
+}
+
+impl Message<MicrophoneSamples> for MicrophoneFeed {
+    type Reply = ();
+
+    async fn handle(
+        &mut self,
+        msg: MicrophoneSamples,
+        _: &mut Context<Self, Self::Reply>,
+    ) -> Self::Reply {
+        let mut to_remove = vec![];
+
+        for (i, sender) in self.senders.iter().enumerate() {
+            if let Err(TrySendError::Disconnected(_)) = sender.try_send(msg.clone()) {
+                warn!("Audio sender {} disconnected, will be removed", i);
+                to_remove.push(i);
+            };
+        }
+
+        if !to_remove.is_empty() {
+            debug!("Removing {} disconnected audio senders", to_remove.len());
+            for i in to_remove.into_iter().rev() {
+                self.senders.swap_remove(i);
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, thiserror::Error)]
+pub enum LockFeedError {
+    #[error(transparent)]
+    Locked(#[from] FeedLockedError),
+    #[error("NoInput")]
+    NoInput,
+    #[error("InitializeFailed/{0}")]
+    InitializeFailed(#[from] SetInputError),
+}
+
+impl Message<Lock> for MicrophoneFeed {
+    type Reply = Result<MicrophoneFeedLock, LockFeedError>;
+
+    async fn handle(&mut self, _: Lock, ctx: &mut Context<Self, Self::Reply>) -> Self::Reply {
+        trace!("MicrophoneFeed.Lock");
+
+        let state = self.state.try_as_open()?;
+
+        if let Some(connecting) = &mut state.connecting {
+            let ready = &mut connecting.ready;
+            let data = ready.await?;
+
+            state.handle_input_connected(data);
+        }
+
+        let Some(attached) = state.attached.take() else {
+            return Err(LockFeedError::NoInput);
+        };
+
+        let config = attached.config.clone();
+
+        self.state = State::Locked { inner: attached };
+
+        Ok(MicrophoneFeedLock {
+            audio_info: AudioInfo::from_stream_config(&config),
+            actor: ctx.actor_ref(),
+            config,
+            lock_tx: ctx.actor_ref().recipient(),
+        })
+    }
+}
+
+impl Message<InputConnected> for MicrophoneFeed {
+    type Reply = Result<(), FeedLockedError>;
+
+    async fn handle(
+        &mut self,
+        msg: InputConnected,
+        _: &mut Context<Self, Self::Reply>,
+    ) -> Self::Reply {
+        trace!("MicrophoneFeed.InputConnected");
+
+        let state = self.state.try_as_open()?;
+
+        state.handle_input_connected(msg);
+
+        Ok(())
+    }
+}
+
+impl Message<InputConnectFailed> for MicrophoneFeed {
+    type Reply = Result<(), FeedLockedError>;
+
+    async fn handle(
+        &mut self,
+        msg: InputConnectFailed,
+        _: &mut Context<Self, Self::Reply>,
+    ) -> Self::Reply {
+        trace!("MicrophoneFeed.InputConnectFailed");
+
+        let state = self.state.try_as_open()?;
+
+        if let Some(connecting) = &state.connecting
+            && connecting.id == msg.id
+        {
+            state.connecting = None;
+        }
+
+        Ok(())
+    }
+}
+
+impl Message<Unlock> for MicrophoneFeed {
+    type Reply = ();
+
+    async fn handle(&mut self, _: Unlock, _: &mut Context<Self, Self::Reply>) -> Self::Reply {
+        trace!("MicrophoneFeed.Unlock");
+
+        replace_with_or_abort(&mut self.state, |state| {
+            if let State::Locked { inner } = state {
+                State::Open(OpenState {
+                    connecting: None,
+                    attached: Some(inner),
+                })
+            } else {
+                state
+            }
+        });
+    }
+}
diff --git a/crates/recording/src/feeds/mod.rs b/crates/recording/src/feeds/mod.rs
index 261dfc43ed..eacc27e846 100644
--- a/crates/recording/src/feeds/mod.rs
+++ b/crates/recording/src/feeds/mod.rs
@@ -1,5 +1,4 @@
-mod audio_input;
 mod camera;
+pub mod microphone;
 
-pub use audio_input::*;
 pub use camera::*;
diff --git a/crates/recording/src/instant_recording.rs b/crates/recording/src/instant_recording.rs
index 9833fb9c7b..86399e6998 100644
--- a/crates/recording/src/instant_recording.rs
+++ b/crates/recording/src/instant_recording.rs
@@ -1,5 +1,5 @@
 use cap_media::MediaError;
-use cap_media_info::VideoInfo;
+use cap_media_info::{AudioInfo, VideoInfo};
 use cap_project::InstantRecordingMeta;
 use cap_utils::{ensure_dir, spawn_actor};
 use flume::Receiver;
@@ -14,7 +14,7 @@ use tracing::{Instrument, debug, error, info, trace};
 use crate::{
     ActorError, RecordingBaseInputs, RecordingError,
     capture_pipeline::{MakeCapturePipeline, create_screen_capture},
-    feeds::AudioInputFeed,
+    feeds::microphone::MicrophoneFeedLock,
     pipeline::Pipeline,
     sources::{ScreenCaptureSource, ScreenCaptureTarget},
 };
@@ -114,7 +114,7 @@ async fn create_pipeline<TCaptureFormat: MakeCapturePipeline>(
         ScreenCaptureSource<TCaptureFormat>,
         flume::Receiver<(TCaptureFormat::VideoFormat, f64)>,
     ),
-    audio_input_feed: Option<&AudioInputFeed>,
+    mic_feed: Option<Arc<MicrophoneFeedLock>>,
     system_audio: Option<Receiver<(ffmpeg::frame::Audio, f64)>>,
 ) -> Result<
     (
@@ -123,6 +123,13 @@ async fn create_pipeline<TCaptureFormat: MakeCapturePipeline>(
     ),
     MediaError,
 > {
+    if let Some(mic_feed) = &mic_feed {
+        debug!(
+            "mic audio info: {:#?}",
+            AudioInfo::from_stream_config(mic_feed.config())
+        );
+    };
+
     let pipeline_builder = Pipeline::builder();
 
     let pause_flag = Arc::new(AtomicBool::new(false));
@@ -130,7 +137,7 @@ async fn create_pipeline<TCaptureFormat: MakeCapturePipeline>(
     let pipeline_builder = TCaptureFormat::make_instant_mode_pipeline(
         pipeline_builder,
         screen_source,
-        audio_input_feed,
+        mic_feed,
         system_audio,
         output_path.clone(),
         pause_flag.clone(),
@@ -151,10 +158,10 @@ async fn create_pipeline<TCaptureFormat: MakeCapturePipeline>(
     ))
 }
 
-pub async fn spawn_instant_recording_actor<'a>(
+pub async fn spawn_instant_recording_actor(
     id: String,
     recording_dir: PathBuf,
-    inputs: RecordingBaseInputs<'a>,
+    inputs: RecordingBaseInputs,
 ) -> Result<
     (
         InstantRecordingHandle,
@@ -184,14 +191,10 @@ pub async fn spawn_instant_recording_actor<'a>(
 
     debug!("screen capture: {screen_source:#?}");
 
-    if let Some(audio_feed) = inputs.mic_feed {
-        debug!("mic audio info: {:#?}", audio_feed.audio_info())
-    }
-
     let (pipeline, pipeline_done_rx) = create_pipeline(
         content_dir.join("output.mp4"),
         (screen_source.clone(), screen_rx.clone()),
-        inputs.mic_feed.as_ref(),
+        inputs.mic_feed.clone(),
         system_audio.1,
     )
     .await?;
diff --git a/crates/recording/src/lib.rs b/crates/recording/src/lib.rs
index 1c615552e9..8ed6604fd0 100644
--- a/crates/recording/src/lib.rs
+++ b/crates/recording/src/lib.rs
@@ -11,12 +11,12 @@ pub use studio_recording::{
     CompletedStudioRecording, StudioRecordingHandle, spawn_studio_recording_actor,
 };
 
-use feeds::AudioInputFeed;
-use sources::*;
-
 use cap_displays::bounds::LogicalBounds;
 use cap_media::MediaError;
+use feeds::microphone::MicrophoneFeedLock;
 use serde::{Deserialize, Serialize};
+use sources::*;
+use std::sync::Arc;
 use thiserror::Error;
 
 #[derive(specta::Type, Serialize, Deserialize, Clone, Debug, Copy)]
@@ -39,10 +39,10 @@ pub struct RecordingOptions {
 }
 
 #[derive(Clone)]
-pub struct RecordingBaseInputs<'a> {
+pub struct RecordingBaseInputs {
     pub capture_target: ScreenCaptureTarget,
     pub capture_system_audio: bool,
-    pub mic_feed: &'a Option<AudioInputFeed>,
+    pub mic_feed: Option<Arc<MicrophoneFeedLock>>,
 }
 
 #[derive(specta::Type, Serialize, Deserialize, Clone, Debug)]
diff --git a/crates/recording/src/sources/audio_input.rs b/crates/recording/src/sources/audio_input.rs
index 677414ae20..55771cbf7a 100644
--- a/crates/recording/src/sources/audio_input.rs
+++ b/crates/recording/src/sources/audio_input.rs
@@ -1,3 +1,7 @@
+use crate::{
+    feeds::microphone::{self, MicrophoneFeedLock, MicrophoneSamples},
+    pipeline::{control::Control, task::PipelineSourceTask},
+};
 use cap_fail::fail;
 use cap_media::MediaError;
 use cap_media_info::AudioInfo;
@@ -5,18 +9,13 @@ use cpal::{Device, StreamInstant, SupportedStreamConfig};
 use ffmpeg::{frame::Audio as FFAudio, sys::AV_TIME_BASE_Q};
 use flume::{Receiver, Sender};
 use indexmap::IndexMap;
-use std::time::SystemTime;
+use std::{sync::Arc, time::SystemTime};
 use tracing::{error, info};
 
-use crate::{
-    feeds::{AudioInputConnection, AudioInputFeed, AudioInputSamples},
-    pipeline::{control::Control, task::PipelineSourceTask},
-};
-
 pub type AudioInputDeviceMap = IndexMap<String, (Device, SupportedStreamConfig)>;
 
 pub struct AudioInputSource {
-    feed_connection: AudioInputConnection,
+    feed: Arc<MicrophoneFeedLock>,
     audio_info: AudioInfo,
     tx: Sender<(FFAudio, f64)>,
     start_timestamp: Option<(StreamInstant, SystemTime)>,
@@ -24,10 +23,14 @@ pub struct AudioInputSource {
 }
 
 impl AudioInputSource {
-    pub fn init(feed: &AudioInputFeed, tx: Sender<(FFAudio, f64)>, start_time: SystemTime) -> Self {
+    pub fn init(
+        feed: Arc<MicrophoneFeedLock>,
+        tx: Sender<(FFAudio, f64)>,
+        start_time: SystemTime,
+    ) -> Self {
         Self {
-            feed_connection: feed.create_connection(),
-            audio_info: feed.audio_info(),
+            audio_info: AudioInfo::from_stream_config(feed.config()),
+            feed,
             tx,
             start_timestamp: None,
             start_time: start_time
@@ -41,7 +44,7 @@ impl AudioInputSource {
         self.audio_info
     }
 
-    fn process_frame(&mut self, samples: AudioInputSamples) -> Result<(), MediaError> {
+    fn process_frame(&mut self, samples: MicrophoneSamples) -> Result<(), MediaError> {
         let start_timestamp = match self.start_timestamp {
             None => *self
                 .start_timestamp
@@ -78,8 +81,8 @@ impl AudioInputSource {
         Ok(())
     }
 
-    fn pause_and_drain_frames(&mut self, frames_rx: Receiver<AudioInputSamples>) {
-        let frames: Vec<AudioInputSamples> = frames_rx.drain().collect();
+    fn pause_and_drain_frames(&mut self, frames_rx: Receiver<MicrophoneSamples>) {
+        let frames: Vec<MicrophoneSamples> = frames_rx.drain().collect();
 
         for frame in frames {
             if let Err(error) = self.process_frame(frame) {
@@ -98,7 +101,7 @@ impl PipelineSourceTask for AudioInputSource {
     ) -> Result<(), String> {
         info!("Preparing audio input source thread...");
 
-        let mut samples_rx: Option<Receiver<AudioInputSamples>> = None;
+        let mut samples_rx: Option<Receiver<MicrophoneSamples>> = None;
         ready_signal.send(Ok(())).unwrap();
 
         fail!("media::sources::audio_input::run");
@@ -106,7 +109,11 @@ impl PipelineSourceTask for AudioInputSource {
         let res = loop {
             match control_signal.last() {
                 Some(Control::Play) => {
-                    let samples = samples_rx.get_or_insert_with(|| self.feed_connection.attach());
+                    let samples = samples_rx.get_or_insert_with(|| {
+                        let (tx, rx) = flume::bounded(5);
+                        let _ = self.feed.ask(microphone::AddSender(tx)).blocking_send();
+                        rx
+                    });
 
                     match samples.recv() {
                         Ok(samples) => {
diff --git a/crates/recording/src/sources/screen_capture/macos.rs b/crates/recording/src/sources/screen_capture/macos.rs
index cd41780b4b..4cfdf16b3f 100644
--- a/crates/recording/src/sources/screen_capture/macos.rs
+++ b/crates/recording/src/sources/screen_capture/macos.rs
@@ -214,8 +214,6 @@ impl PipelineSourceTask for ScreenCaptureSource<CMSampleBufferCapture> {
                     .map_err(SourceError::CreateActor)?,
                 );
 
-                let stop_recipient = capturer.clone().reply_recipient::<StopCapturing>();
-
                 let _ = capturer
                     .ask(StartCapturing)
                     .await
diff --git a/crates/recording/src/studio_recording.rs b/crates/recording/src/studio_recording.rs
index 8011c0a158..6226408721 100644
--- a/crates/recording/src/studio_recording.rs
+++ b/crates/recording/src/studio_recording.rs
@@ -1,4 +1,11 @@
-use cap_media::MediaError;
+use crate::{
+    ActorError, MediaError, RecordingBaseInputs, RecordingError,
+    capture_pipeline::{MakeCapturePipeline, ScreenCaptureMethod, create_screen_capture},
+    cursor::{CursorActor, Cursors /*spawn_cursor_recorder*/, spawn_cursor_recorder},
+    feeds::{CameraFeed, microphone::MicrophoneFeedLock},
+    pipeline::Pipeline,
+    sources::{AudioInputSource, CameraSource, ScreenCaptureFormat, ScreenCaptureTarget},
+};
 use cap_media_encoders::{H264Encoder, MP4File, OggFile, OpusEncoder};
 use cap_media_info::VideoInfo;
 use cap_project::{CursorEvents, StudioRecordingMeta};
@@ -14,15 +21,6 @@ use std::{
 use tokio::sync::{Mutex, oneshot};
 use tracing::{debug, info, trace};
 
-use crate::{
-    ActorError, RecordingBaseInputs, RecordingError,
-    capture_pipeline::{MakeCapturePipeline, ScreenCaptureMethod, create_screen_capture},
-    cursor::{CursorActor, Cursors /*spawn_cursor_recorder*/, spawn_cursor_recorder},
-    feeds::{AudioInputFeed, CameraFeed},
-    pipeline::Pipeline,
-    sources::{AudioInputSource, CameraSource, ScreenCaptureFormat, ScreenCaptureTarget},
-};
-
 #[allow(clippy::large_enum_variant)]
 enum StudioRecordingActorState {
     Recording {
@@ -128,10 +126,10 @@ pub enum SpawnStudioRecordingError {
     PipelineCreationError(#[from] CreateSegmentPipelineError),
 }
 
-pub async fn spawn_studio_recording_actor<'a>(
+pub async fn spawn_studio_recording_actor(
     id: String,
     recording_dir: PathBuf,
-    base_inputs: RecordingBaseInputs<'a>,
+    base_inputs: RecordingBaseInputs,
     camera_feed: Option<Arc<Mutex<CameraFeed>>>,
     custom_cursor_capture: bool,
 ) -> Result<(StudioRecordingHandle, oneshot::Receiver<Result<(), String>>), SpawnStudioRecordingError>
@@ -157,16 +155,15 @@ pub async fn spawn_studio_recording_actor<'a>(
         debug!("camera video info: {:#?}", camera_feed.video_info());
     }
 
-    if let Some(audio_feed) = base_inputs.mic_feed {
-        debug!("mic audio info: {:#?}", audio_feed.audio_info())
-    }
-    let audio_input_feed = base_inputs.mic_feed.clone();
+    if let Some(mic_feed) = &base_inputs.mic_feed {
+        debug!("mic audio info: {:#?}", mic_feed.audio_info());
+    };
 
     let mut segment_pipeline_factory = SegmentPipelineFactory::new(
         segments_dir,
         cursors_dir,
         base_inputs.capture_target.clone(),
-        audio_input_feed,
+        base_inputs.mic_feed.clone(),
         base_inputs.capture_system_audio,
         camera_feed,
         custom_cursor_capture,
@@ -570,7 +567,7 @@ struct SegmentPipelineFactory {
     segments_dir: PathBuf,
     cursors_dir: PathBuf,
     capture_target: ScreenCaptureTarget,
-    audio_input_feed: Option<AudioInputFeed>,
+    mic_feed: Option<Arc<MicrophoneFeedLock>>,
     capture_system_audio: bool,
     camera_feed: Option<Arc<Mutex<CameraFeed>>>,
     custom_cursor_capture: bool,
@@ -585,7 +582,7 @@ impl SegmentPipelineFactory {
         segments_dir: PathBuf,
         cursors_dir: PathBuf,
         capture_target: ScreenCaptureTarget,
-        audio_input_feed: Option<AudioInputFeed>,
+        mic_feed: Option<Arc<MicrophoneFeedLock>>,
         capture_system_audio: bool,
         camera_feed: Option<Arc<Mutex<CameraFeed>>>,
         custom_cursor_capture: bool,
@@ -596,7 +593,7 @@ impl SegmentPipelineFactory {
             segments_dir,
             cursors_dir,
             capture_target,
-            audio_input_feed,
+            mic_feed,
             capture_system_audio,
             camera_feed,
             custom_cursor_capture,
@@ -622,7 +619,7 @@ impl SegmentPipelineFactory {
             &self.cursors_dir,
             self.index,
             self.capture_target.clone(),
-            &self.audio_input_feed,
+            self.mic_feed.clone(),
             self.capture_system_audio,
             self.camera_feed.as_deref(),
             cursors,
@@ -664,7 +661,7 @@ async fn create_segment_pipeline(
     cursors_dir: &Path,
     index: u32,
     capture_target: ScreenCaptureTarget,
-    mic_feed: &Option<AudioInputFeed>,
+    mic_feed: Option<Arc<MicrophoneFeedLock>>,
     capture_system_audio: bool,
     camera_feed: Option<&Mutex<CameraFeed>>,
     prev_cursors: Cursors,
@@ -744,10 +741,10 @@ async fn create_segment_pipeline(
         }
     };
 
-    let microphone = if let Some(mic_source) = mic_feed {
+    let microphone = if let Some(mic_feed) = mic_feed {
         let (tx, rx) = flume::bounded(8);
 
-        let mic_source = AudioInputSource::init(mic_source, tx, start_time);
+        let mic_source = AudioInputSource::init(mic_feed, tx, start_time);
 
         let mic_config = mic_source.info();
         let output_path = dir.join("audio-input.ogg");
diff --git a/crates/scap-direct3d/examples/cli.rs b/crates/scap-direct3d/examples/cli.rs
index 1e6c9f5879..0103a2eea0 100644
--- a/crates/scap-direct3d/examples/cli.rs
+++ b/crates/scap-direct3d/examples/cli.rs
@@ -18,32 +18,17 @@ mod windows {
         let capturer = Capturer::new(
             display.try_as_capture_item().unwrap(),
             Settings {
-                is_border_required: Some(false),
+                is_border_required: Some(true),
                 is_cursor_capture_enabled: Some(true),
                 pixel_format: PixelFormat::R8G8B8A8Unorm,
-                crop: Some(D3D11_BOX {
-                    left: 0,
-                    top: 0,
-                    right: 500,
-                    bottom: 400,
-                    front: 0,
-                    back: 1,
-                }),
-                ..Default::default()
             },
         );
 
-        let capture_handle = capturer.start(
-            |frame| {
-                dbg!(&frame);
+        let capture_handle = capturer.start(|frame| {
+            dbg!(frame);
 
-                let ff_frame = frame.as_ffmpeg()?;
-                dbg!(ff_frame.width(), ff_frame.height(), ff_frame.format());
-
-                Ok(())
-            },
-            || Ok(()),
-        );
+            Ok(())
+        });
 
         std::thread::sleep(Duration::from_secs(3));
 
diff --git a/packages/ui-solid/src/auto-imports.d.ts b/packages/ui-solid/src/auto-imports.d.ts
index 792d482761..0dfc727b51 100644
--- a/packages/ui-solid/src/auto-imports.d.ts
+++ b/packages/ui-solid/src/auto-imports.d.ts
@@ -3,6 +3,7 @@
 // @ts-nocheck
 // noinspection JSUnusedGlobalSymbols
 // Generated by unplugin-auto-import
+// biome-ignore lint: disable
 export {};
 declare global {
 	const IconCapArrows: typeof import("~icons/cap/arrows.jsx")["default"];