diff --git a/electron/cameraPreview.test.ts b/electron/cameraPreview.test.ts
new file mode 100644
index 000000000..2a6add0ff
--- /dev/null
+++ b/electron/cameraPreview.test.ts
@@ -0,0 +1,209 @@
+import { EventEmitter } from "node:events";
+import type { BrowserWindow, WebContents } from "electron";
+import { describe, expect, it, vi } from "vitest";
+import { collectMacCaptureExcludedWindowIds } from "../src/lib/nativeMacRecording";
+import { CameraPreviewController } from "./cameraPreview";
+
+function setup() {
+	const owner = Object.assign(new EventEmitter(), { send: vi.fn() });
+	const overlay = Object.assign(new EventEmitter(), {
+		getMediaSourceId: () => "window:123:0",
+		webContents: { send: vi.fn() },
+		showInactive: vi.fn(),
+		hide: vi.fn(),
+		destroy: vi.fn(() => {
+			overlay.emit("closed");
+		}),
+	});
+	const create = vi.fn(() => overlay as unknown as BrowserWindow);
+	const resize = vi.fn();
+	const preview = new CameraPreviewController(create, resize);
+	const sender = owner as unknown as WebContents;
+	const overlaySender = overlay.webContents as unknown as WebContents;
+	return { owner, overlay, create, resize, preview, sender, overlaySender };
+}
+
+const jpeg = "data:image/jpeg;base64,/9j/";
+
+describe("floating camera preview lifecycle", () => {
+	it("reserves the same exclusion ID before the renderer enables the preview", () => {
+		const { preview, sender, overlay, create } = setup();
+		const reserved = preview.ensure(sender);
+		const excludedIds = collectMacCaptureExcludedWindowIds([reserved!.getMediaSourceId()]);
+		expect(excludedIds).toContain(123);
+		overlay.emit("ready-to-show");
+		expect(overlay.showInactive).not.toHaveBeenCalled();
+		preview.configure(sender, true, true);
+		expect(preview.ensure(sender)).toBe(reserved);
+		expect(create).toHaveBeenCalledOnce();
+		expect(overlay.showInactive).toHaveBeenCalledOnce();
+		expect(excludedIds).toContain(123);
+	});
+
+	it("ensuring an existing preview preserves visibility and refuses a different owner", () => {
+		const { preview, sender, overlay, create } = setup();
+		preview.configure(sender, true, true);
+		overlay.emit("ready-to-show");
+		expect(preview.ensure(sender)).toBe(overlay);
+		expect(preview.ensure({} as WebContents)).toBeNull();
+		preview.frame(sender, jpeg);
+		expect(overlay.webContents.send).toHaveBeenCalledWith("camera-preview:frame", jpeg);
+		expect(overlay.hide).not.toHaveBeenCalled();
+		expect(create).toHaveBeenCalledOnce();
+	});
+
+	it("waits for the window to paint, then shows without taking focus", () => {
+		const { preview, sender, overlay } = setup();
+		preview.configure(sender, true, true);
+		expect(overlay.showInactive).not.toHaveBeenCalled();
+		overlay.emit("ready-to-show");
+		expect(overlay.showInactive).toHaveBeenCalledOnce();
+	});
+
+	it("hides and restores the same window, retaining its capture exclusion id", () => {
+		const { preview, sender, overlaySender, overlay, owner, create } = setup();
+		preview.configure(sender, true, true);
+		overlay.emit("ready-to-show");
+		preview.hide(overlaySender);
+		expect(owner.send).toHaveBeenCalledWith("camera-preview:hidden");
+		preview.frame(sender, jpeg);
+		expect(overlay.webContents.send).not.toHaveBeenCalled();
+		preview.configure(sender, true, true);
+		expect(create).toHaveBeenCalledOnce();
+		expect(overlay.destroy).not.toHaveBeenCalled();
+		preview.frame(sender, jpeg);
+		expect(overlay.webContents.send).toHaveBeenCalledWith("camera-preview:frame", jpeg);
+	});
+
+	it("does not flash a preview disabled before its renderer is ready", () => {
+		const { preview, sender, overlay } = setup();
+		preview.configure(sender, true, true);
+		preview.configure(sender, true, false);
+		overlay.emit("ready-to-show");
+		expect(overlay.showInactive).not.toHaveBeenCalled();
+	});
+
+	it("ignores other renderers and rejects oversized or non-JPEG frames", () => {
+		const { preview, sender, overlay, create } = setup();
+		const stranger = {} as WebContents;
+		preview.configure(sender, true, true);
+		preview.configure(stranger, false, false);
+		preview.hide(stranger);
+		for (const invalid of [undefined, "https://example.com/camera", jpeg + "x".repeat(128_000)]) {
+			preview.frame(sender, invalid);
+		}
+		preview.frame(stranger, jpeg);
+		expect(overlay.webContents.send).not.toHaveBeenCalled();
+		expect(overlay.destroy).not.toHaveBeenCalled();
+		expect(create).toHaveBeenCalledOnce();
+	});
+
+	it("allows only the preview to resize to a supported width without replacing its window", () => {
+		const { preview, sender, overlaySender, resize, create, overlay } = setup();
+		preview.configure(sender, true, true);
+		preview.resize(sender, 320);
+		preview.resize(overlaySender, Number.NaN);
+		preview.resize(overlaySender, 10000);
+		expect(resize).not.toHaveBeenCalled();
+		preview.resize(overlaySender, 320);
+		expect(resize).toHaveBeenCalledWith(overlay, 320, 16 / 9);
+		expect(create).toHaveBeenCalledOnce();
+		expect(overlay.destroy).not.toHaveBeenCalled();
+	});
+
+	it("sizes the same window to the delivered frame and preserves that ratio on resize", () => {
+		const { preview, sender, overlaySender, resize, overlay } = setup();
+		preview.configure(sender, true, true);
+		preview.frame(sender, jpeg, 9 / 16);
+		expect(resize).toHaveBeenLastCalledWith(overlay, 224, 9 / 16);
+		preview.resize(overlaySender, 320);
+		expect(resize).toHaveBeenLastCalledWith(overlay, 320, 9 / 16);
+		const calls = resize.mock.calls.length;
+		for (const ratio of [0, -1, Number.NaN, Number.POSITIVE_INFINITY, 100, "16:9"]) {
+			preview.frame(sender, jpeg, ratio);
+		}
+		expect(resize).toHaveBeenCalledTimes(calls);
+	});
+
+	it("recreates an unexpectedly closed preview and waits for the replacement to be ready", () => {
+		const { preview, sender, overlay, create } = setup();
+		const replacement = setup().overlay;
+		create
+			.mockReturnValueOnce(overlay as unknown as BrowserWindow)
+			.mockReturnValueOnce(replacement as unknown as BrowserWindow);
+		preview.configure(sender, true, true);
+		overlay.emit("ready-to-show");
+		overlay.emit("closed");
+		preview.frame(sender, jpeg);
+		expect(overlay.webContents.send).not.toHaveBeenCalled();
+
+		preview.configure(sender, true, true);
+		expect(create).toHaveBeenCalledTimes(2);
+		expect(replacement.showInactive).not.toHaveBeenCalled();
+		replacement.emit("ready-to-show");
+		expect(replacement.showInactive).toHaveBeenCalledOnce();
+	});
+
+	it("ignores a stale closed event from a previously disposed preview", () => {
+		const { preview, sender, overlay, create } = setup();
+		// Delay closure to exercise a late event after the replacement already exists.
+		overlay.destroy.mockImplementationOnce(() => undefined);
+		const replacement = setup().overlay;
+		create
+			.mockReturnValueOnce(overlay as unknown as BrowserWindow)
+			.mockReturnValueOnce(replacement as unknown as BrowserWindow);
+		preview.configure(sender, true, true);
+		preview.dispose();
+		preview.configure(sender, true, true);
+		replacement.emit("ready-to-show");
+
+		overlay.emit("closed");
+		preview.frame(sender, jpeg);
+		expect(replacement.webContents.send).toHaveBeenCalledWith("camera-preview:frame", jpeg);
+		preview.configure(sender, true, true);
+		expect(create).toHaveBeenCalledTimes(2);
+		expect(replacement.showInactive).toHaveBeenCalledTimes(2);
+	});
+
+	it("destroys the auxiliary window when the HUD is destroyed", () => {
+		const { preview, sender, owner, overlay } = setup();
+		preview.configure(sender, true, true);
+		owner.emit("destroyed");
+		expect(overlay.destroy).toHaveBeenCalledOnce();
+		preview.frame(sender, jpeg);
+		expect(overlay.webContents.send).not.toHaveBeenCalled();
+	});
+
+	it("creates a hidden exclusion window even when the camera starts off", () => {
+		const { preview, sender, owner, overlay, create } = setup();
+		preview.configure(sender, false, true);
+		overlay.emit("ready-to-show");
+		expect(create).toHaveBeenCalledOnce();
+		expect(overlay.hide).toHaveBeenCalledOnce();
+		expect(overlay.showInactive).not.toHaveBeenCalled();
+		preview.frame(sender, jpeg);
+		expect(overlay.webContents.send).not.toHaveBeenCalled();
+		preview.configure(sender, true, true);
+		expect(create).toHaveBeenCalledOnce();
+		expect(overlay.showInactive).toHaveBeenCalledOnce();
+		owner.emit("destroyed");
+		expect(overlay.destroy).toHaveBeenCalledOnce();
+	});
+
+	it("retains the exclusion window and one owner listener across camera toggles", () => {
+		const { preview, sender, owner, overlay, create } = setup();
+		for (let i = 0; i < 15; i++) {
+			preview.configure(sender, true, true);
+			if (i === 0) overlay.emit("ready-to-show");
+			preview.configure(sender, false, true);
+		}
+		expect(create).toHaveBeenCalledOnce();
+		expect(overlay.hide).toHaveBeenCalledTimes(15);
+		expect(overlay.showInactive).toHaveBeenCalledTimes(15);
+		expect(overlay.destroy).not.toHaveBeenCalled();
+		expect(owner.listenerCount("destroyed")).toBe(1);
+		owner.emit("destroyed");
+		expect(owner.listenerCount("destroyed")).toBe(0);
+		expect(overlay.destroy).toHaveBeenCalledOnce();
+	});
+});
diff --git a/electron/cameraPreview.ts b/electron/cameraPreview.ts
new file mode 100644
index 000000000..9f1ff2ec7
--- /dev/null
+++ b/electron/cameraPreview.ts
@@ -0,0 +1,120 @@
+import type { BrowserWindow, WebContents } from "electron";
+import {
+	CAMERA_PREVIEW_DEFAULT_ASPECT_RATIO,
+	CAMERA_PREVIEW_DEFAULT_SIZE,
+	CAMERA_PREVIEW_SIZES,
+} from "../src/lib/cameraPreview";
+
+/** One stable window per HUD: hiding it must not change the native capture exclusion id. */
+export class CameraPreviewController {
+	private window: BrowserWindow | null = null;
+	private owner: WebContents | null = null;
+	private visible = false;
+	private width: number = CAMERA_PREVIEW_DEFAULT_SIZE;
+	private aspectRatio = CAMERA_PREVIEW_DEFAULT_ASPECT_RATIO;
+	private ready = false;
+	private onOwnerDestroyed: (() => void) | null = null;
+
+	constructor(
+		private readonly createWindow: () => BrowserWindow,
+		private readonly resizeWindow: (
+			window: BrowserWindow,
+			width: number,
+			aspectRatio: number,
+		) => void,
+	) {}
+
+	/** Reserve the capture-exclusion window before renderer configuration arrives. */
+	ensure(owner: WebContents): BrowserWindow | null {
+		if (this.owner && this.owner !== owner) return null;
+		if (!this.owner) {
+			this.owner = owner;
+			this.onOwnerDestroyed = () => {
+				if (this.owner === owner) this.dispose();
+			};
+			owner.once("destroyed", this.onOwnerDestroyed);
+		}
+		if (!this.window) {
+			this.window = this.createWindow();
+			const previewWindow = this.window;
+			previewWindow.once("closed", () => {
+				if (this.window !== previewWindow) return;
+				this.window = null;
+				this.ready = false;
+				this.visible = false;
+			});
+			this.window.once("ready-to-show", () => {
+				if (this.window !== previewWindow) return;
+				this.ready = true;
+				this.resizeWindow(previewWindow, this.width, this.aspectRatio);
+				if (this.visible) this.window?.showInactive();
+			});
+		}
+		return this.window;
+	}
+
+	configure(owner: WebContents, enabled: boolean, visible: boolean): void {
+		const previewWindow = this.ensure(owner);
+		if (!previewWindow) return;
+		this.visible = enabled && visible;
+		if (this.visible && this.ready) previewWindow.showInactive();
+		else if (!this.visible) previewWindow.hide();
+	}
+
+	hide(sender: WebContents): void {
+		if (sender !== this.window?.webContents) return;
+		this.visible = false;
+		this.window.hide();
+		this.owner?.send("camera-preview:hidden");
+	}
+
+	resize(sender: WebContents, width: unknown): void {
+		if (
+			sender !== this.window?.webContents ||
+			typeof width !== "number" ||
+			!CAMERA_PREVIEW_SIZES.some((size) => size === width)
+		)
+			return;
+		this.width = width;
+		this.resizeWindow(this.window, this.width, this.aspectRatio);
+	}
+
+	frame(sender: WebContents, jpeg: unknown, aspectRatio?: unknown): void {
+		if (sender !== this.owner || !this.visible || !this.window) return;
+		// A 320px JPEG is usually under 20KB. Never relay arbitrary URLs or unbounded IPC data.
+		if (
+			typeof jpeg !== "string" ||
+			jpeg.length > 128_000 ||
+			!jpeg.startsWith("data:image/jpeg;base64,")
+		)
+			return;
+		if (aspectRatio !== undefined) {
+			if (
+				typeof aspectRatio !== "number" ||
+				!Number.isFinite(aspectRatio) ||
+				aspectRatio < 1 / 8 ||
+				aspectRatio > 8
+			)
+				return;
+			if (this.aspectRatio !== aspectRatio) {
+				this.aspectRatio = aspectRatio;
+				this.resizeWindow(this.window, this.width, aspectRatio);
+			}
+		}
+		this.window.webContents.send("camera-preview:frame", jpeg);
+	}
+
+	dispose(): void {
+		if (this.owner && this.onOwnerDestroyed) {
+			this.owner.removeListener("destroyed", this.onOwnerDestroyed);
+		}
+		this.onOwnerDestroyed = null;
+		this.ready = false;
+		this.window?.destroy();
+		this.window = null;
+		this.owner = null;
+		this.visible = false;
+		this.width = CAMERA_PREVIEW_DEFAULT_SIZE;
+		this.aspectRatio = CAMERA_PREVIEW_DEFAULT_ASPECT_RATIO;
+	}
+}
diff --git a/electron/electron-env.d.ts b/electron/electron-env.d.ts
index fc6b5f911..71045aa7a 100644
--- a/electron/electron-env.d.ts
+++ b/electron/electron-env.d.ts
@@ -58,6 +58,12 @@ interface Window {
 		usesSystemSourcePicker?: () => Promise<boolean>;
 		/** Name of the last source picked in Apple's picker, for display only: it is not selected. */
 		getLastPickedSource?: () => Promise<string | null>;
+		configureCameraPreview?: (enabled: boolean, visible: boolean) => Promise<void>;
+		sendCameraPreviewFrame?: (jpeg: string, aspectRatio: number) => Promise<void>;
+		resizeCameraPreview?: (width: number) => Promise<void>;
+		hideCameraPreview?: () => Promise<void>;
+		onCameraPreviewFrame?: (callback: (jpeg: string) => void) => () => void;
+		onCameraPreviewHidden?: (callback: () => void) => () => void;
 		openNotes: () => Promise<{
 			opened: boolean;
 			reason?: string;
diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts
index ee36e105f..afcd04fc0 100644
--- a/electron/ipc/handlers.ts
+++ b/electron/ipc/handlers.ts
@@ -69,6 +69,7 @@ import { DocumentService } from "../ai-edition/document-service";
 import { LlmConfigStore } from "../ai-edition/llm-config-store";
 import { StylePresetService } from "../ai-edition/style-preset-service";
 import { AppSettingsStore } from "../app-settings";
+import { CameraPreviewController } from "../cameraPreview";
 import { createRunnerHost } from "../cli/runnerHost";
 import { hideCountdownOverlay } from "../countdownOverlay";
 import { isDiagnosticModeEnabled, mainLogBuffer } from "../diagnostics/main-log-buffer";
@@ -161,7 +162,12 @@ import {
 	shouldPersistSelectedSource,
 } from "../recording-source-settings";
 import { getSttManager } from "../stt";
-import { createRunnerWindow } from "../windows";
+import {
+	createCameraPreviewWindow,
+	createRunnerWindow,
+	getCameraPreviewWindow,
+	resizeCameraPreviewWindow,
+} from "../windows";
 import { getSourcesByType, shouldEnumerateSourceTypesSeparately } from "./desktopSourceTypes";
 import { registerNativeBridgeHandlers } from "./nativeBridge";
 import { createNativeMacMidCaptureErrorWatch } from "./nativeMacMidCaptureErrorWatch";
@@ -2141,7 +2147,8 @@ export function registerIpcHandlers(
 	 * pick would record them unless the picker is told to leave them out.
 	 */
 	function macPickerExcludedWindowIds() {
-		const appWindowSourceIds = [getMainWindow(), getNotesWindow()]
+		ensureMacCameraPreviewWindow();
+		const appWindowSourceIds = [getMainWindow(), getNotesWindow(), getCameraPreviewWindow()]
 			.filter((window): window is BrowserWindow => !!window && !window.isDestroyed())
 			.map((window) => window.getMediaSourceId());
 		return collectMacCaptureExcludedWindowIds(appWindowSourceIds);
@@ -2470,6 +2477,38 @@ export function registerIpcHandlers(
 		return { opened: true };
 	});
 
+	const cameraPreview = new CameraPreviewController(
+		createCameraPreviewWindow,
+		resizeCameraPreviewWindow,
+	);
+	function ensureMacCameraPreviewWindow() {
+		const hud = getMainWindow();
+		if (
+			process.platform === "darwin" &&
+			hud &&
+			!hud.isDestroyed() &&
+			new URL(hud.webContents.getURL()).searchParams.get("windowType") === "hud-overlay"
+		) {
+			cameraPreview.ensure(hud.webContents);
+		}
+	}
+	ipcMain.handle("camera-preview:configure", (event, enabled: unknown, visible: unknown) => {
+		if (
+			process.platform !== "darwin" ||
+			event.sender !== getMainWindow()?.webContents ||
+			new URL(event.sender.getURL()).searchParams.get("windowType") !== "hud-overlay"
+		)
+			return;
+		cameraPreview.configure(event.sender, enabled === true, visible === true);
+	});
+	ipcMain.handle("camera-preview:frame", (event, jpeg: unknown, aspectRatio: unknown) =>
+		cameraPreview.frame(event.sender, jpeg, aspectRatio),
+	);
+	ipcMain.handle("camera-preview:hide", (event) => cameraPreview.hide(event.sender));
+	ipcMain.handle("camera-preview:resize", (event, diameter: unknown) =>
+		cameraPreview.resize(event.sender, diameter),
+	);
+
 	ipcMain.handle("open-notes", async () => {
 		const notesSelectorWin = getNotesWindow();
 		if (notesSelectorWin) {
@@ -3148,6 +3187,7 @@ export function registerIpcHandlers(
 				normalizeCursorCaptureMode(request.cursor?.mode) ?? "editable-overlay";
 			// A source from Apple's picker records through the session that holds the pick,
 			// and needs no Screen Recording grant -- so nothing here may go near one.
+			ensureMacCameraPreviewWindow();
 			const pickerSession = isMacPickerSourceId(request.source.sourceId) ? macPickerSession : null;
 			// Normally caught by `get-selected-source` first; this is the last word (#965).
 			pickerSession?.forgetSelectionUnlessExcluding(macPickerExcludedWindowIds());
@@ -3192,7 +3232,7 @@ export function registerIpcHandlers(
 				pick?.bounds ?? request.source.bounds ?? sourceDisplay?.bounds ?? getSelectedSourceBounds();
 			const captureExcludedWindowSourceIds: string[] = [];
 			if (request.source.type === "display") {
-				for (const window of [getMainWindow(), getNotesWindow()]) {
+				for (const window of [getMainWindow(), getNotesWindow(), getCameraPreviewWindow()]) {
 					if (window && !window.isDestroyed()) {
 						captureExcludedWindowSourceIds.push(window.getMediaSourceId());
 					}
diff --git a/electron/native/screencapturekit/Sources/OpenScreenScreenCaptureKitHelper/ScreenCaptureRecorder.swift b/electron/native/screencapturekit/Sources/OpenScreenScreenCaptureKitHelper/ScreenCaptureRecorder.swift
index 1450f130d..e204556bf 100644
--- a/electron/native/screencapturekit/Sources/OpenScreenScreenCaptureKitHelper/ScreenCaptureRecorder.swift
+++ b/electron/native/screencapturekit/Sources/OpenScreenScreenCaptureKitHelper/ScreenCaptureRecorder.swift
@@ -215,9 +215,11 @@ final class ScreenCaptureRecorder: NSObject, SCStreamOutput, SCStreamDelegate {
 		if let picked {
 			target = makeCaptureTarget(picked: picked)
 		} else {
+			// Keep hidden recording overlays in the filter, so showing a camera preview
+			// during the take never exposes it while the exclusion-refresh poll catches up.
 			let content = try await SCShareableContent.excludingDesktopWindows(
 				false,
-				onScreenWindowsOnly: true
+				onScreenWindowsOnly: false
 			)
 			target = try makeCaptureTarget(from: content)
 			if recordsSystemAudioFromDisplay, let display = content.displays.first {
@@ -671,7 +673,7 @@ final class ScreenCaptureRecorder: NSObject, SCStreamOutput, SCStreamDelegate {
 				guard let self, let stream = self.stream,
 					let content = try? await SCShareableContent.excludingDesktopWindows(
 						false,
-						onScreenWindowsOnly: true
+						onScreenWindowsOnly: false
 					),
 					let display = content.displays.first(where: { $0.displayID == displayID })
 				else {
diff --git a/electron/preload.ts b/electron/preload.ts
index 23160bcaa..c0d6c15f4 100644
--- a/electron/preload.ts
+++ b/electron/preload.ts
@@ -169,6 +169,23 @@ contextBridge.exposeInMainWorld("electronAPI", {
 	getLastPickedSource: (): Promise<string | null> => {
 		return ipcRenderer.invoke("get-last-picked-source");
 	},
+	configureCameraPreview: (enabled: boolean, visible: boolean): Promise<void> =>
+		ipcRenderer.invoke("camera-preview:configure", enabled, visible),
+	sendCameraPreviewFrame: (jpeg: string, aspectRatio: number): Promise<void> =>
+		ipcRenderer.invoke("camera-preview:frame", jpeg, aspectRatio),
+	resizeCameraPreview: (width: number): Promise<void> =>
+		ipcRenderer.invoke("camera-preview:resize", width),
+	hideCameraPreview: (): Promise<void> => ipcRenderer.invoke("camera-preview:hide"),
+	onCameraPreviewFrame: (callback: (jpeg: string) => void) => {
+		const listener = (_event: Electron.IpcRendererEvent, jpeg: string) => callback(jpeg);
+		ipcRenderer.on("camera-preview:frame", listener);
+		return () => ipcRenderer.removeListener("camera-preview:frame", listener);
+	},
+	onCameraPreviewHidden: (callback: () => void) => {
+		const listener = () => callback();
+		ipcRenderer.on("camera-preview:hidden", listener);
+		return () => ipcRenderer.removeListener("camera-preview:hidden", listener);
+	},
 	openNotes: () => {
 		return ipcRenderer.invoke("open-notes");
 	},
diff --git a/electron/windows.ts b/electron/windows.ts
index 8db7d9cd4..9a95afcf0 100644
--- a/electron/windows.ts
+++ b/electron/windows.ts
@@ -1,6 +1,7 @@
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { app, BrowserWindow, ipcMain, screen } from "electron";
+import { cameraPreviewBounds, resizedCameraPreviewBounds } from "../src/lib/cameraPreview";
 import {
 	fitEditorRect,
 	loadEditorWindowState,
@@ -860,6 +861,78 @@ export function createPermissionsWindow(): BrowserWindow {
 	return win;
 }
 
+let cameraPreviewWindow: BrowserWindow | null = null;
+
+export function getCameraPreviewWindow(): BrowserWindow | null {
+	return cameraPreviewWindow && !cameraPreviewWindow.isDestroyed() ? cameraPreviewWindow : null;
+}
+
+/** The camera stream belongs to the HUD; this window only displays preview frames. */
+export function createCameraPreviewWindow(): BrowserWindow {
+	const initialBounds = () => {
+		const bar =
+			hudOverlayWindow && !hudOverlayWindow.isDestroyed() && hudContentRect
+				? hudContentScreenRect(hudOverlayWindow.getBounds(), hudContentRect)
+				: undefined;
+		const workArea = bar
+			? screen.getDisplayMatching(bar).workArea
+			: screen.getPrimaryDisplay().workArea;
+		return cameraPreviewBounds(workArea, bar);
+	};
+	const win = new BrowserWindow({
+		...initialBounds(),
+		title: "OpenScreen - Camera Preview",
+		hasShadow: false,
+		frame: false,
+		transparent: true,
+		backgroundColor: "#00000000",
+		resizable: false,
+		maximizable: false,
+		minimizable: false,
+		alwaysOnTop: true,
+		skipTaskbar: true,
+		show: false,
+		webPreferences: {
+			preload: path.join(__dirname, "preload.mjs"),
+			additionalArguments: [ASSET_BASE_URL_ARG],
+			nodeIntegration: false,
+			contextIsolation: true,
+			backgroundThrottling: false,
+		},
+	});
+	win.once("ready-to-show", () => win.setBounds(initialBounds()));
+	applyContentProtection(win, "Camera Preview");
+	followAcrossSpaces(win);
+	cameraPreviewWindow = win;
+	win.on("closed", () => {
+		if (cameraPreviewWindow === win) cameraPreviewWindow = null;
+	});
+	if (VITE_DEV_SERVER_URL) {
+		win.loadURL(VITE_DEV_SERVER_URL + "?windowType=camera-preview");
+	} else {
+		win.loadFile(path.join(RENDERER_DIST, "index.html"), {
+			query: { windowType: "camera-preview" },
+		});
+	}
+	return win;
+}
+
+export function resizeCameraPreviewWindow(
+	win: BrowserWindow,
+	width: number,
+	aspectRatio: number,
+): void {
+	const bounds = win.getBounds();
+	win.setBounds(
+		resizedCameraPreviewBounds(
+			bounds,
+			screen.getDisplayMatching(bounds).workArea,
+			width,
+			aspectRatio,
+		),
+	);
+}
+
 // Frameless Notes Window for taking notes during a recording.
 export function createNotesWindow(): BrowserWindow {
 	const win = new BrowserWindow({
diff --git a/src/App.tsx b/src/App.tsx
index 681bb5993..c326d3b83 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -6,6 +6,7 @@ import { installBrowserShims } from "./native/browserShim";
 installBrowserShims();
 
 import { CountdownOverlay } from "./components/launch/CountdownOverlay.tsx";
+import { FloatingCameraPreview } from "./components/launch/FloatingCameraPreview";
 import { LaunchWindow } from "./components/launch/LaunchWindow";
 import { NotesWindow } from "./components/launch/NotesWindow.tsx";
 import { SourceSelector } from "./components/launch/SourceSelector";
@@ -52,7 +53,7 @@ export default function App() {
 			setWindowType(type);
 		}
 
-		if (type === "hud-overlay" || type === "source-selector" || type === "countdown-overlay") {
+		if (["hud-overlay", "source-selector", "countdown-overlay", "camera-preview"].includes(type)) {
 			document.body.style.background = "transparent";
 			document.documentElement.style.background = "transparent";
 			document.getElementById("root")?.style.setProperty("background", "transparent");
@@ -60,7 +61,7 @@ export default function App() {
 
 		// HUD is a fixed-size BrowserWindow; pin the document shell and hide overflow
 		// so the renderer can't introduce scrollbars (see issue #305).
-		if (type === "hud-overlay") {
+		if (type === "hud-overlay" || type === "camera-preview") {
 			document.documentElement.style.height = "100%";
 			document.documentElement.style.overflow = "hidden";
 			document.body.style.height = "100%";
@@ -85,6 +86,8 @@ export default function App() {
 		switch (windowType) {
 			case "hud-overlay":
 				return <LaunchWindow />;
+			case "camera-preview":
+				return <FloatingCameraPreview />;
 			case "source-selector":
 				return <SourceSelector />;
 			case "countdown-overlay":
diff --git a/src/components/launch/FloatingCameraPreview.module.css b/src/components/launch/FloatingCameraPreview.module.css
new file mode 100644
index 000000000..ee65ec55e
--- /dev/null
+++ b/src/components/launch/FloatingCameraPreview.module.css
@@ -0,0 +1,87 @@
+.preview {
+	-webkit-app-region: drag;
+	position: relative;
+	display: grid;
+	place-items: center;
+	width: calc(100% - 16px);
+	height: calc(100% - 16px);
+	margin: 8px;
+	overflow: hidden;
+	border-radius: 12px;
+	background: #09090b;
+	color: #a1a1aa;
+	font-size: 12px;
+	cursor: grab;
+}
+
+.preview img {
+	position: absolute;
+	inset: 0;
+	width: 100%;
+	height: 100%;
+	object-fit: contain;
+	object-position: center;
+}
+
+.hide {
+	-webkit-app-region: no-drag;
+	position: absolute;
+	top: 8px;
+	right: 8px;
+	display: grid;
+	place-items: center;
+	width: 28px;
+	height: 28px;
+	border-radius: 50%;
+	background: #09090bbf;
+	color: #f4f4f5;
+	cursor: pointer;
+	opacity: 0;
+	transition: opacity 120ms ease;
+}
+
+.preview:hover .hide,
+.preview:focus-within .hide {
+	opacity: 1;
+}
+
+.hide:focus-visible {
+	outline: 2px solid #10b981;
+}
+
+.sizeControls {
+	-webkit-app-region: no-drag;
+	position: absolute;
+	bottom: 8px;
+	left: 50%;
+	display: flex;
+	gap: 4px;
+	transform: translateX(-50%);
+	opacity: 0;
+	transition: opacity 120ms ease;
+}
+
+.sizeControls button {
+	display: grid;
+	place-items: center;
+	width: 28px;
+	height: 28px;
+	border-radius: 50%;
+	background: #09090bbf;
+	color: #f4f4f5;
+	cursor: pointer;
+}
+
+.sizeControls button:disabled {
+	opacity: 0.4;
+	cursor: default;
+}
+
+.preview:hover .sizeControls,
+.preview:focus-within .sizeControls {
+	opacity: 1;
+}
+
+.sizeControls button:focus-visible {
+	outline: 2px solid #10b981;
+}
diff --git a/src/components/launch/FloatingCameraPreview.test.tsx b/src/components/launch/FloatingCameraPreview.test.tsx
new file mode 100644
index 000000000..08194f994
--- /dev/null
+++ b/src/components/launch/FloatingCameraPreview.test.tsx
@@ -0,0 +1,37 @@
+// @vitest-environment jsdom
+import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, expect, it, vi } from "vitest";
+import { FloatingCameraPreview } from "./FloatingCameraPreview";
+
+vi.mock("../../contexts/I18nContext", () => ({ useScopedT: () => (key: string) => key }));
+afterEach(cleanup);
+
+it("displays incoming frames and offers three bounded preview sizes", async () => {
+	let frame: ((jpeg: string) => void) | undefined;
+	const resize = vi.fn().mockResolvedValue(undefined);
+	const unsubscribe = vi.fn();
+	window.electronAPI = {
+		onCameraPreviewFrame: (callback: (jpeg: string) => void) => {
+			frame = callback;
+			return unsubscribe;
+		},
+		resizeCameraPreview: resize,
+	} as unknown as Window["electronAPI"];
+	const view = render(<FloatingCameraPreview />);
+	act(() => frame?.("data:image/jpeg;base64,frame"));
+	expect(screen.getByAltText("floatingCamera.title").getAttribute("src")).toBe(
+		"data:image/jpeg;base64,frame",
+	);
+	const larger = screen.getByRole("button", { name: "floatingCamera.larger" });
+	const smaller = screen.getByRole("button", { name: "floatingCamera.smaller" });
+	fireEvent.click(larger);
+	await waitFor(() => expect((larger as HTMLButtonElement).disabled).toBe(true));
+	expect(resize).toHaveBeenLastCalledWith(320);
+	fireEvent.click(smaller);
+	await waitFor(() => expect((larger as HTMLButtonElement).disabled).toBe(false));
+	fireEvent.click(smaller);
+	await waitFor(() => expect((smaller as HTMLButtonElement).disabled).toBe(true));
+	expect(resize).toHaveBeenLastCalledWith(160);
+	view.unmount();
+	expect(unsubscribe).toHaveBeenCalledOnce();
+});
diff --git a/src/components/launch/FloatingCameraPreview.tsx b/src/components/launch/FloatingCameraPreview.tsx
new file mode 100644
index 000000000..cdd21f351
--- /dev/null
+++ b/src/components/launch/FloatingCameraPreview.tsx
@@ -0,0 +1,59 @@
+import { Minus, Plus, X } from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+import { useScopedT } from "../../contexts/I18nContext";
+import { CAMERA_PREVIEW_SIZES } from "../../lib/cameraPreview";
+import styles from "./FloatingCameraPreview.module.css";
+
+export function FloatingCameraPreview() {
+	const t = useScopedT("launch");
+	const image = useRef<HTMLImageElement>(null);
+	const [ready, setReady] = useState(false);
+	const [sizeIndex, setSizeIndex] = useState(1);
+	const resize = (next: number) => {
+		void window.electronAPI
+			?.resizeCameraPreview?.(CAMERA_PREVIEW_SIZES[next])
+			.then(() => setSizeIndex(next))
+			.catch((error: unknown) => console.warn("Could not resize camera preview:", error));
+	};
+	useEffect(
+		() =>
+			window.electronAPI?.onCameraPreviewFrame?.((jpeg) => {
+				if (image.current) image.current.src = jpeg;
+				setReady(true);
+			}),
+		[],
+	);
+
+	return (
+		<div className={styles.preview} data-testid="floating-camera-preview">
+			<img ref={image} alt={t("floatingCamera.title")} hidden={!ready} draggable={false} />
+			{!ready && <span>{t("deviceSettings.previewUnavailable")}</span>}
+			<button
+				type="button"
+				className={styles.hide}
+				aria-label={t("floatingCamera.hide")}
+				onClick={() => void window.electronAPI?.hideCameraPreview?.()}
+			>
+				<X size={16} aria-hidden="true" />
+			</button>
+			<div className={styles.sizeControls}>
+				<button
+					type="button"
+					aria-label={t("floatingCamera.smaller")}
+					disabled={sizeIndex === 0}
+					onClick={() => resize(sizeIndex - 1)}
+				>
+					<Minus size={16} aria-hidden="true" />
+				</button>
+				<button
+					type="button"
+					aria-label={t("floatingCamera.larger")}
+					disabled={sizeIndex === CAMERA_PREVIEW_SIZES.length - 1}
+					onClick={() => resize(sizeIndex + 1)}
+				>
+					<Plus size={16} aria-hidden="true" />
+				</button>
+			</div>
+		</div>
+	);
+}
diff --git a/src/components/launch/HudControls.tsx b/src/components/launch/HudControls.tsx
index 2c5fa7df1..93322a7bd 100644
--- a/src/components/launch/HudControls.tsx
+++ b/src/components/launch/HudControls.tsx
@@ -1,4 +1,4 @@
-import { Check, Languages, NotepadText, Settings } from "lucide-react";
+import { Check, Eye, EyeOff, Languages, NotepadText, Settings } from "lucide-react";
 import {
 	createContext,
 	memo,
@@ -297,6 +297,38 @@ export const HudMicButton = memo(function HudMicButton({
 	);
 });
 
+export function HudCameraPreviewButton({
+	visible,
+	disabled,
+	label,
+	onClick,
+}: {
+	visible: boolean;
+	disabled: boolean;
+	label: string;
+	onClick: () => void;
+}) {
+	return (
+		<HudTooltip content={label}>
+			<button
+				type="button"
+				data-testid="launch-camera-preview-button"
+				className={`${hudIconBtnClasses} ${hudLockedClasses}`}
+				aria-label={label}
+				aria-pressed={visible}
+				aria-disabled={disabled || undefined}
+				onClick={disabled ? undefined : onClick}
+			>
+				{visible ? (
+					<Eye className="text-[#10b981]" size={ICON_SIZE} />
+				) : (
+					<EyeOff size={ICON_SIZE} />
+				)}
+			</button>
+		</HudTooltip>
+	);
+}
+
 export const HudCameraButton = memo(function HudCameraButton({
 	enabled,
 	locked,
diff --git a/src/components/launch/LaunchWindow.test.tsx b/src/components/launch/LaunchWindow.test.tsx
index 8cd92de95..44a7640c9 100644
--- a/src/components/launch/LaunchWindow.test.tsx
+++ b/src/components/launch/LaunchWindow.test.tsx
@@ -2374,3 +2374,52 @@ describe("LaunchWindow toasts", () => {
 		});
 	});
 });
+
+describe("macOS floating camera preview control", () => {
+	beforeEach(() => {
+		platformState.value = "darwin";
+		resetLaunchMocks();
+	});
+
+	it("keeps hide/show available during recording without changing camera capture", () => {
+		recorderState.value.webcamEnabled = true;
+		recorderState.value.recording = true;
+		renderLaunchWindow();
+		const button = screen.getByTestId("launch-camera-preview-button");
+		expect(button).toHaveAttribute("aria-pressed", "true");
+		fireEvent.click(button);
+		expect(button).toHaveAttribute("aria-pressed", "false");
+		fireEvent.click(button);
+		expect(button).toHaveAttribute("aria-pressed", "true");
+		expect(recorderState.value.setWebcamEnabled).not.toHaveBeenCalled();
+	});
+
+	it("hides the preview control when the camera is off", () => {
+		const view = renderLaunchWindow();
+		expect(screen.queryByTestId("launch-camera-preview-button")).not.toBeInTheDocument();
+		recorderState.value.webcamEnabled = true;
+		view.rerender(
+			<TooltipProvider>
+				<LaunchWindow />
+			</TooltipProvider>,
+		);
+		expect(screen.getByTestId("launch-camera-preview-button")).toHaveAttribute(
+			"aria-pressed",
+			"true",
+		);
+		recorderState.value.webcamEnabled = false;
+		view.rerender(
+			<TooltipProvider>
+				<LaunchWindow />
+			</TooltipProvider>,
+		);
+		expect(screen.queryByTestId("launch-camera-preview-button")).not.toBeInTheDocument();
+	});
+
+	it("does not offer the preview on Windows", () => {
+		platformState.value = "win32";
+		recorderState.value.webcamEnabled = true;
+		renderLaunchWindow();
+		expect(screen.queryByTestId("launch-camera-preview-button")).not.toBeInTheDocument();
+	});
+});
diff --git a/src/components/launch/LaunchWindow.tsx b/src/components/launch/LaunchWindow.tsx
index d4b402b84..7094529af 100644
--- a/src/components/launch/LaunchWindow.tsx
+++ b/src/components/launch/LaunchWindow.tsx
@@ -8,6 +8,7 @@ import { nativeBridgeClient } from "@/native";
 import { canRecordMicrophone, getPlatform } from "@/utils/platformUtils";
 import { type CameraDevice } from "../../hooks/useCameraDevices";
 import { useCameraHudSync } from "../../hooks/useCameraHudSync";
+import { useFloatingCameraPreview } from "../../hooks/useFloatingCameraPreview";
 import {
 	isPlaceholderMicrophoneLabel,
 	type MicrophoneDevice,
@@ -21,6 +22,7 @@ import { requestCameraAccess } from "../../lib/requestCameraAccess";
 import { Toaster } from "../ui/sonner";
 import {
 	HudCameraButton,
+	HudCameraPreviewButton,
 	HudCursorButton,
 	HudDivider,
 	HudDragHandle,
@@ -104,6 +106,7 @@ export function LaunchWindow() {
 	const languageCode = locale.split("-")[0].toUpperCase();
 
 	const {
+		webcamPreviewStream,
 		recording,
 		paused,
 		saving,
@@ -137,6 +140,9 @@ export function LaunchWindow() {
 	} = useScreenRecorder();
 
 	// Choosing a device and switching one on are deliberately separate concerns.
+	const cameraPreview = useFloatingCameraPreview(webcamPreviewStream, webcamEnabled && !saving);
+	const cameraPreviewShown = webcamEnabled && !saving && cameraPreview.visible;
+
 	// The mic and camera buttons are plain on/off toggles that use whatever device
 	// is currently selected (the system default until the user says otherwise);
 	// picking a different device — and checking it actually works — happens in the
@@ -1279,6 +1285,14 @@ export function LaunchWindow() {
 								tooltip={t("tooltips.camera")}
 								onClick={toggleWebcam}
 							/>
+							{cameraPreview.supported && webcamEnabled && (
+								<HudCameraPreviewButton
+									visible={cameraPreviewShown}
+									disabled={saving}
+									label={t(cameraPreviewShown ? "floatingCamera.hide" : "floatingCamera.show")}
+									onClick={cameraPreview.toggle}
+								/>
+							)}
 							<HudSettingsButton
 								buttonRef={settingsTriggerRef}
 								locked={controlsLocked}
diff --git a/src/hooks/useFloatingCameraPreview.test.tsx b/src/hooks/useFloatingCameraPreview.test.tsx
new file mode 100644
index 000000000..0c0279c0d
--- /dev/null
+++ b/src/hooks/useFloatingCameraPreview.test.tsx
@@ -0,0 +1,109 @@
+// @vitest-environment jsdom
+import { act, cleanup, renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useFloatingCameraPreview } from "./useFloatingCameraPreview";
+
+vi.mock("../utils/platformUtils", () => ({ getPlatform: () => platform }));
+let platform = "darwin";
+let hidden: (() => void) | undefined;
+const configure = vi.fn().mockResolvedValue(undefined);
+const send = vi.fn().mockResolvedValue(undefined);
+const unsubscribe = vi.fn();
+const stop = vi.fn();
+const stream = { getTracks: () => [{ stop }] } as unknown as MediaStream;
+
+beforeEach(() => {
+	vi.useFakeTimers();
+	platform = "darwin";
+	vi.clearAllMocks();
+	Object.defineProperty(window, "electronAPI", {
+		configurable: true,
+		value: {
+			configureCameraPreview: configure,
+			sendCameraPreviewFrame: send,
+			onCameraPreviewHidden: (callback: () => void) => {
+				hidden = callback;
+				return unsubscribe;
+			},
+		},
+	});
+	vi.spyOn(HTMLMediaElement.prototype, "play").mockResolvedValue(undefined);
+	vi.spyOn(HTMLMediaElement.prototype, "pause").mockImplementation(() => undefined);
+	vi.spyOn(HTMLCanvasElement.prototype, "getContext").mockReturnValue({
+		drawImage: vi.fn(),
+	} as unknown as CanvasRenderingContext2D);
+	vi.spyOn(HTMLCanvasElement.prototype, "toDataURL").mockReturnValue(
+		"data:image/jpeg;base64,frame",
+	);
+	vi.spyOn(HTMLMediaElement.prototype, "readyState", "get").mockReturnValue(2);
+	vi.spyOn(HTMLVideoElement.prototype, "videoWidth", "get").mockReturnValue(1280);
+	vi.spyOn(HTMLVideoElement.prototype, "videoHeight", "get").mockReturnValue(720);
+});
+
+afterEach(() => {
+	cleanup();
+	vi.useRealTimers();
+	vi.restoreAllMocks();
+});
+
+describe("floating camera publisher", () => {
+	it("shares frames without acquiring or stopping the recording camera", async () => {
+		const { unmount } = renderHook(() => useFloatingCameraPreview(stream, true));
+		expect(configure).toHaveBeenLastCalledWith(true, true);
+		expect(send).toHaveBeenCalledOnce();
+		expect(send).toHaveBeenCalledWith("data:image/jpeg;base64,frame", 1280 / 720);
+		await act(() => vi.advanceTimersByTimeAsync(300));
+		expect(send).toHaveBeenCalledTimes(4);
+		unmount();
+		await vi.advanceTimersByTimeAsync(500);
+		expect(send).toHaveBeenCalledTimes(4);
+		expect(stop).not.toHaveBeenCalled();
+		expect(configure).toHaveBeenLastCalledWith(false, false);
+		expect(unsubscribe).toHaveBeenCalledOnce();
+	});
+
+	it("hides without disabling the camera, then resumes from the HUD control", () => {
+		const { result } = renderHook(() => useFloatingCameraPreview(stream, true));
+		act(() => hidden?.());
+		expect(configure).toHaveBeenLastCalledWith(true, false);
+		expect(result.current.visible).toBe(false);
+		act(() => result.current.toggle());
+		expect(configure).toHaveBeenLastCalledWith(true, true);
+		expect(stop).not.toHaveBeenCalled();
+	});
+
+	it("applies backpressure while a previous frame is still being delivered", async () => {
+		let delivered: (() => void) | undefined;
+		send.mockImplementationOnce(
+			() =>
+				new Promise<void>((resolve) => {
+					delivered = resolve;
+				}),
+		);
+		renderHook(() => useFloatingCameraPreview(stream, true));
+		await act(() => vi.advanceTimersByTimeAsync(1000));
+		expect(send).toHaveBeenCalledOnce();
+		await act(async () => {
+			delivered?.();
+		});
+		await act(() => vi.advanceTimersByTimeAsync(100));
+		expect(send).toHaveBeenCalledTimes(2);
+	});
+
+	it("waits for the recorder stream and never opens a preview on other platforms", () => {
+		const { rerender, unmount } = renderHook(
+			({ enabled }) => useFloatingCameraPreview(null, enabled),
+			{ initialProps: { enabled: true } },
+		);
+		expect(configure).toHaveBeenLastCalledWith(true, false);
+		expect(send).not.toHaveBeenCalled();
+		rerender({ enabled: false });
+		expect(configure).toHaveBeenLastCalledWith(false, false);
+		unmount();
+		configure.mockClear();
+		platform = "win32";
+		renderHook(() => useFloatingCameraPreview(stream, true));
+		expect(configure).not.toHaveBeenCalled();
+		expect(send).not.toHaveBeenCalled();
+	});
+});
diff --git a/src/hooks/useFloatingCameraPreview.ts b/src/hooks/useFloatingCameraPreview.ts
new file mode 100644
index 000000000..3d1f1108b
--- /dev/null
+++ b/src/hooks/useFloatingCameraPreview.ts
@@ -0,0 +1,66 @@
+import { useEffect, useState } from "react";
+import { getPlatform } from "../utils/platformUtils";
+
+/** A small self-view from the recorder's stream; never acquires or stops the camera. */
+export function useFloatingCameraPreview(stream: MediaStream | null, enabled: boolean) {
+	const supported = getPlatform() === "darwin";
+	const [visible, setVisible] = useState(true);
+
+	useEffect(() => window.electronAPI?.onCameraPreviewHidden?.(() => setVisible(false)), []);
+
+	useEffect(() => {
+		if (!supported) return;
+		void window.electronAPI
+			?.configureCameraPreview?.(enabled, enabled && visible && !!stream)
+			.catch((error: unknown) => console.warn("Could not configure camera preview:", error));
+	}, [enabled, visible, stream, supported]);
+
+	useEffect(() => {
+		if (!supported || !enabled || !visible || !stream) return;
+		const video = document.createElement("video");
+		video.muted = true;
+		video.playsInline = true;
+		video.srcObject = stream;
+		void video.play().catch(() => undefined);
+		const canvas = document.createElement("canvas");
+		canvas.width = 320;
+		canvas.height = 180;
+		const context = canvas.getContext("2d");
+		let cancelled = false;
+		let timer: ReturnType<typeof setTimeout>;
+		const draw = async () => {
+			try {
+				if (context && video.readyState >= 2 && video.videoWidth > 0 && video.videoHeight > 0) {
+					canvas.height = Math.max(1, Math.round((320 * video.videoHeight) / video.videoWidth));
+					context.drawImage(video, 0, 0, canvas.width, canvas.height);
+					// Await delivery: a slow renderer must not build a queue of stale frames.
+					await window.electronAPI?.sendCameraPreviewFrame?.(
+						canvas.toDataURL("image/jpeg", 0.7),
+						video.videoWidth / video.videoHeight,
+					);
+				}
+			} catch (error) {
+				console.warn("Could not update camera preview:", error);
+			} finally {
+				if (!cancelled) timer = setTimeout(() => void draw(), 100);
+			}
+		};
+		void draw();
+		return () => {
+			cancelled = true;
+			clearTimeout(timer);
+			video.pause();
+			video.srcObject = null;
+		};
+	}, [enabled, visible, stream, supported]);
+
+	useEffect(
+		() => () => {
+			if (supported)
+				void window.electronAPI?.configureCameraPreview?.(false, false).catch(() => undefined);
+		},
+		[supported],
+	);
+
+	return { supported, visible, toggle: () => setVisible((value) => !value) };
+}
diff --git a/src/hooks/useScreenRecorder.cameraPrefs.test.tsx b/src/hooks/useScreenRecorder.cameraPrefs.test.tsx
new file mode 100644
index 000000000..d60d1a56d
--- /dev/null
+++ b/src/hooks/useScreenRecorder.cameraPrefs.test.tsx
@@ -0,0 +1,99 @@
+// @vitest-environment jsdom
+import { act, cleanup, renderHook, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { useCameraHudSync } from "./useCameraHudSync";
+import { useScreenRecorder } from "./useScreenRecorder";
+
+vi.mock("@/contexts/I18nContext", () => {
+	const translate = (key: string) => key;
+	return { useScopedT: () => translate };
+});
+vi.mock("sonner", () => ({ toast: { error: vi.fn(), warning: vi.fn(), info: vi.fn() } }));
+vi.mock("./useCameraDevices", () => ({
+	useCameraDevices: (_enabled: boolean, preferred?: string) => ({
+		selectedDeviceId: preferred ?? "cam-1",
+		selectedDevice: { label: preferred === "cam-2" ? "Camera 2" : "Camera 1" },
+		isReady: true,
+	}),
+}));
+
+type Prefs = Awaited<ReturnType<Window["electronAPI"]["getRecordingPrefs"]>>;
+const initial: Prefs = {
+	micEnabled: false,
+	micDeviceId: null,
+	micDeviceName: null,
+	camEnabled: true,
+	camDeviceId: null,
+	camDeviceName: null,
+	camQuality: "2160p",
+	systemAudioEnabled: false,
+	cursorCaptureMode: "editable-overlay",
+	hideDesktopIcons: false,
+	autoZoomEnabled: true,
+};
+
+afterEach(() => {
+	cleanup();
+	window.history.replaceState({}, "", "/");
+	vi.restoreAllMocks();
+});
+
+function setup() {
+	window.history.replaceState({}, "", "/?windowType=hud-overlay");
+	let publish: ((prefs: Prefs) => void) | undefined;
+	const stops: Array<ReturnType<typeof vi.fn>> = [];
+	const getUserMedia = vi.fn(async () => {
+		const stop = vi.fn();
+		stops.push(stop);
+		const track = { stop, onended: null };
+		return { getTracks: () => [track], getVideoTracks: () => [track] } as unknown as MediaStream;
+	});
+	Object.defineProperty(navigator, "mediaDevices", { configurable: true, value: { getUserMedia } });
+	window.electronAPI = {
+		getPlatform: () => "darwin",
+		getRecordingPrefs: async () => initial,
+		onRecordingPrefsChanged: (callback: (prefs: Prefs) => void) => {
+			publish = callback;
+			return () => undefined;
+		},
+		hideCountdownOverlay: vi.fn().mockResolvedValue(undefined),
+	} as unknown as Window["electronAPI"];
+	const view = renderHook(() => {
+		const recorder = useScreenRecorder();
+		useCameraHudSync(recorder);
+		return recorder;
+	});
+	return { view, getUserMedia, stops, publish: (prefs: Prefs) => publish?.(prefs) };
+}
+
+describe("camera preview across recording preference broadcasts", () => {
+	it("keeps the resolved default camera stream alive when audio toggles publish unchanged camera preferences", async () => {
+		const { view, getUserMedia, stops, publish } = setup();
+		await waitFor(() => expect(view.result.current.webcamPreviewStream).not.toBeNull());
+		const stream = view.result.current.webcamPreviewStream;
+		const calls = getUserMedia.mock.calls.length;
+		const stop = stops.at(-1);
+		await act(async () => {
+			view.result.current.setSystemAudioEnabled(true);
+			publish({ ...initial, systemAudioEnabled: true });
+		});
+		await act(async () => {
+			view.result.current.setMicrophoneEnabled(true);
+			publish({ ...initial, micEnabled: true, systemAudioEnabled: true });
+		});
+		expect(view.result.current.webcamPreviewStream).toBe(stream);
+		expect(getUserMedia).toHaveBeenCalledTimes(calls);
+		expect(stop).not.toHaveBeenCalled();
+	});
+
+	it("still applies a changed camera selection and an explicit reset to the default", async () => {
+		const { view, publish } = setup();
+		await waitFor(() => expect(view.result.current.webcamPreviewStream).not.toBeNull());
+		const first = view.result.current.webcamPreviewStream;
+		await act(async () => publish({ ...initial, camDeviceId: "cam-2", camDeviceName: "Camera 2" }));
+		expect(view.result.current.webcamDeviceId).toBe("cam-2");
+		expect(view.result.current.webcamPreviewStream).not.toBe(first);
+		await act(async () => publish(initial));
+		expect(view.result.current.webcamDeviceId).toBe("cam-1");
+	});
+});
diff --git a/src/hooks/useScreenRecorder.noCamera.test.tsx b/src/hooks/useScreenRecorder.noCamera.test.tsx
index cd75f16b8..4958a8fbf 100644
--- a/src/hooks/useScreenRecorder.noCamera.test.tsx
+++ b/src/hooks/useScreenRecorder.noCamera.test.tsx
@@ -2,9 +2,10 @@
 import { act, renderHook, waitFor } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-vi.mock("@/contexts/I18nContext", () => ({
-	useScopedT: () => (key: string) => key,
-}));
+vi.mock("@/contexts/I18nContext", () => {
+	const translate = (key: string) => key;
+	return { useScopedT: () => translate };
+});
 
 vi.mock("sonner", () => ({
 	toast: { error: vi.fn(), success: vi.fn(), info: vi.fn(), warning: vi.fn() },
@@ -101,7 +102,9 @@ describe("useScreenRecorder on a machine without a camera (#967)", () => {
 
 		expect(ok).toBe(true);
 		expect(view.result.current.webcamEnabled).toBe(true);
-		await waitFor(() => expect(getUserMedia).toHaveBeenCalled());
+		await waitFor(() => expect(view.result.current.webcamPreviewStream).not.toBeNull());
+		expect(view.result.current.webcamPreviewStream).toBe(await getUserMedia.mock.results[0].value);
+		expect(getUserMedia).toHaveBeenCalledTimes(1);
 		expect(setRecordingPrefs).not.toHaveBeenCalled();
 	});
 
diff --git a/src/hooks/useScreenRecorder.ts b/src/hooks/useScreenRecorder.ts
index c5156749b..3e432353d 100644
--- a/src/hooks/useScreenRecorder.ts
+++ b/src/hooks/useScreenRecorder.ts
@@ -88,6 +88,7 @@ const AUDIO_BITRATE_VOICE = 128_000;
 const AUDIO_BITRATE_SYSTEM = 192_000;
 
 type UseScreenRecorderReturn = {
+	webcamPreviewStream: MediaStream | null;
 	recording: boolean;
 	paused: boolean;
 	saving: boolean;
@@ -285,6 +286,10 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 	useEffect(() => {
 		let cancelled = false;
 		let receivedNewerSnapshot = false;
+		let appliedCameraSelection: {
+			deviceId: string | undefined;
+			deviceName: string | undefined;
+		} | null = null;
 		const applyPrefs = (prefs: {
 			micEnabled: boolean;
 			micDeviceId?: string | null;
@@ -307,8 +312,24 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 				new URLSearchParams(window.location.search).get("windowType") === "cli-record";
 			if (!isCliRecord) {
 				setWebcamEnabledState(prefs.camEnabled);
-				setWebcamDeviceId(prefs.camDeviceId ?? undefined);
-				setWebcamDeviceName(prefs.camDeviceName ?? undefined);
+				const deviceId = prefs.camDeviceId ?? undefined;
+				const deviceName = prefs.camDeviceName ?? undefined;
+				// The HUD resolves a stored default (null) to a concrete device locally.
+				// An audio-only save republishes that same null: applying it again would
+				// reset the resolved device, stop its stream, and visibly blink the preview.
+				const isMacHud =
+					window.electronAPI?.getPlatform?.() === "darwin" &&
+					new URLSearchParams(window.location.search).get("windowType") === "hud-overlay";
+				if (
+					!isMacHud ||
+					!appliedCameraSelection ||
+					appliedCameraSelection.deviceId !== deviceId ||
+					appliedCameraSelection.deviceName !== deviceName
+				) {
+					setWebcamDeviceId(deviceId);
+					setWebcamDeviceName(deviceName);
+					appliedCameraSelection = { deviceId, deviceName };
+				}
 			}
 			setWebcamQuality(webcamQualityFrom(prefs.camQuality));
 			setSystemAudioEnabled(prefs.systemAudioEnabled);
@@ -351,6 +372,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 	const screenStream = useRef<MediaStream | null>(null);
 	const microphoneStream = useRef<MediaStream | null>(null);
 	const webcamStream = useRef<MediaStream | null>(null);
+	const [webcamPreviewStream, setWebcamPreviewStream] = useState<MediaStream | null>(null);
 	const mixingContext = useRef<AudioContext | null>(null);
 	const recordingId = useRef<number>(0);
 	const accumulatedDurationMs = useRef(0);
@@ -467,6 +489,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 			track.stop();
 		});
 		webcamStream.current = null;
+		setWebcamPreviewStream(null);
 		webcamReady.current = true;
 	}, []);
 
@@ -514,6 +537,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 				stream.getVideoTracks().forEach((track) => {
 					track.onended = () => {
 						webcamStream.current = null;
+						setWebcamPreviewStream(null);
 						if (!restarting.current) {
 							setWebcamEnabledState(false);
 							toast.error(t("recording.cameraDisconnected"));
@@ -521,6 +545,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 					};
 				});
 				webcamStream.current = stream;
+				setWebcamPreviewStream(stream);
 				webcamReady.current = true;
 			} catch (cameraError) {
 				if (isRecoverableWebcamConstraintError(cameraError, webcamDeviceName)) {
@@ -560,6 +585,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 					track.stop();
 				});
 				webcamStream.current = null;
+				setWebcamPreviewStream(null);
 			}
 		};
 	}, [webcamEnabled, webcamDeviceId, webcamDeviceName, webcamQuality, t]);
@@ -2459,6 +2485,7 @@ export function useScreenRecorder(): UseScreenRecorderReturn {
 	};
 
 	return {
+		webcamPreviewStream,
 		recording,
 		paused,
 		saving,
diff --git a/src/i18n/locales/ar/launch.json b/src/i18n/locales/ar/launch.json
index ef613d15d..538b34e26 100644
--- a/src/i18n/locales/ar/launch.json
+++ b/src/i18n/locales/ar/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "معاينة الكاميرا",
+		"show": "إظهار معاينة الكاميرا",
+		"hide": "إخفاء معاينة الكاميرا",
+		"smaller": "تصغير المعاينة",
+		"larger": "تكبير المعاينة"
+	},
 	"tooltips": {
 		"hideHUD": "إخفاء واجهة العرض",
 		"hideHUDTip": "إخفاء الشريط. يمكنك إظهاره مجددًا من أيقونة علبة النظام.",
diff --git a/src/i18n/locales/cs/launch.json b/src/i18n/locales/cs/launch.json
index d9912da51..a5a63939a 100644
--- a/src/i18n/locales/cs/launch.json
+++ b/src/i18n/locales/cs/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "Náhled kamery",
+		"show": "Zobrazit náhled kamery",
+		"hide": "Skrýt náhled kamery",
+		"smaller": "Zmenšit náhled",
+		"larger": "Zvětšit náhled"
+	},
 	"tooltips": {
 		"hideHUD": "Skrýt HUD",
 		"hideHUDTip": "Skrýt panel. Znovu ho zobrazíte z ikony v oznamovací oblasti.",
diff --git a/src/i18n/locales/de/launch.json b/src/i18n/locales/de/launch.json
index b4dab82a9..204b6e858 100644
--- a/src/i18n/locales/de/launch.json
+++ b/src/i18n/locales/de/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "Kameravorschau",
+		"show": "Kameravorschau anzeigen",
+		"hide": "Kameravorschau ausblenden",
+		"smaller": "Vorschau verkleinern",
+		"larger": "Vorschau vergrößern"
+	},
 	"tooltips": {
 		"hideHUD": "HUD ausblenden",
 		"hideHUDTip": "Aufnahmeleiste ausblenden. Über das Symbol im Infobereich wieder einblenden.",
diff --git a/src/i18n/locales/en/launch.json b/src/i18n/locales/en/launch.json
index 97263f184..4987f2396 100644
--- a/src/i18n/locales/en/launch.json
+++ b/src/i18n/locales/en/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "Camera preview",
+		"show": "Show camera preview",
+		"hide": "Hide camera preview",
+		"smaller": "Decrease preview size",
+		"larger": "Increase preview size"
+	},
 	"tooltips": {
 		"hideHUD": "Hide recording bar",
 		"hideHUDTip": "Hide the recording bar. Show it again from the tray icon.",
diff --git a/src/i18n/locales/es/launch.json b/src/i18n/locales/es/launch.json
index 3114921ec..fc230bba7 100644
--- a/src/i18n/locales/es/launch.json
+++ b/src/i18n/locales/es/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "Vista previa de cámara",
+		"show": "Mostrar vista previa de cámara",
+		"hide": "Ocultar vista previa de cámara",
+		"smaller": "Reducir vista previa",
+		"larger": "Ampliar vista previa"
+	},
 	"tooltips": {
 		"hideHUD": "Ocultar HUD",
 		"hideHUDTip": "Ocultar la barra. Vuelve a mostrarla desde el icono de la bandeja del sistema.",
diff --git a/src/i18n/locales/fr/launch.json b/src/i18n/locales/fr/launch.json
index c956fb37a..b768831ed 100644
--- a/src/i18n/locales/fr/launch.json
+++ b/src/i18n/locales/fr/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "Aperçu de la caméra",
+		"show": "Afficher l’aperçu de la caméra",
+		"hide": "Masquer l’aperçu de la caméra",
+		"smaller": "Réduire l’aperçu",
+		"larger": "Agrandir l’aperçu"
+	},
 	"tooltips": {
 		"hideHUD": "Masquer le HUD",
 		"hideHUDTip": "Masquer la barre. Réaffichez-la depuis l'icône de la zone de notification.",
diff --git a/src/i18n/locales/it/launch.json b/src/i18n/locales/it/launch.json
index 9897b92eb..cad6d1551 100644
--- a/src/i18n/locales/it/launch.json
+++ b/src/i18n/locales/it/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "Anteprima della videocamera",
+		"show": "Mostra anteprima della videocamera",
+		"hide": "Nascondi anteprima della videocamera",
+		"smaller": "Riduci anteprima",
+		"larger": "Ingrandisci anteprima"
+	},
 	"tooltips": {
 		"hideHUD": "Nascondi",
 		"hideHUDTip": "Nascondi la barra. Puoi mostrarla di nuovo dall'icona nell'area di notifica.",
diff --git a/src/i18n/locales/ja-JP/launch.json b/src/i18n/locales/ja-JP/launch.json
index 9f2323eec..a18f71ded 100644
--- a/src/i18n/locales/ja-JP/launch.json
+++ b/src/i18n/locales/ja-JP/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "カメラプレビュー",
+		"show": "カメラプレビューを表示",
+		"hide": "カメラプレビューを非表示",
+		"smaller": "プレビューを縮小",
+		"larger": "プレビューを拡大"
+	},
 	"tooltips": {
 		"hideHUD": "HUDを隠す",
 		"hideHUDTip": "録画バーを隠します。通知領域のアイコンから再表示できます。",
diff --git a/src/i18n/locales/ko-KR/launch.json b/src/i18n/locales/ko-KR/launch.json
index 5ce2b8e72..455a84146 100644
--- a/src/i18n/locales/ko-KR/launch.json
+++ b/src/i18n/locales/ko-KR/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "카메라 미리보기",
+		"show": "카메라 미리보기 표시",
+		"hide": "카메라 미리보기 숨기기",
+		"smaller": "미리보기 축소",
+		"larger": "미리보기 확대"
+	},
 	"tooltips": {
 		"hideHUD": "HUD 숨기기",
 		"hideHUDTip": "녹화 바를 숨깁니다. 알림 영역 아이콘에서 다시 표시할 수 있습니다.",
diff --git a/src/i18n/locales/pt-BR/launch.json b/src/i18n/locales/pt-BR/launch.json
index 886615088..893576b96 100644
--- a/src/i18n/locales/pt-BR/launch.json
+++ b/src/i18n/locales/pt-BR/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "Prévia da câmera",
+		"show": "Mostrar prévia da câmera",
+		"hide": "Ocultar prévia da câmera",
+		"smaller": "Diminuir prévia",
+		"larger": "Aumentar prévia"
+	},
 	"tooltips": {
 		"hideHUD": "Ocultar HUD",
 		"hideHUDTip": "Ocultar a barra. Mostre-a de novo pelo ícone da bandeja do sistema.",
diff --git a/src/i18n/locales/ru/launch.json b/src/i18n/locales/ru/launch.json
index cdc103c0b..a34023430 100644
--- a/src/i18n/locales/ru/launch.json
+++ b/src/i18n/locales/ru/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "Предпросмотр камеры",
+		"show": "Показать предпросмотр камеры",
+		"hide": "Скрыть предпросмотр камеры",
+		"smaller": "Уменьшить предпросмотр",
+		"larger": "Увеличить предпросмотр"
+	},
 	"tooltips": {
 		"hideHUD": "Скрыть HUD",
 		"hideHUDTip": "Скрыть панель. Вернуть её можно через значок в области уведомлений.",
diff --git a/src/i18n/locales/tr/launch.json b/src/i18n/locales/tr/launch.json
index 530157dd2..929709e36 100644
--- a/src/i18n/locales/tr/launch.json
+++ b/src/i18n/locales/tr/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "Kamera önizlemesi",
+		"show": "Kamera önizlemesini göster",
+		"hide": "Kamera önizlemesini gizle",
+		"smaller": "Önizlemeyi küçült",
+		"larger": "Önizlemeyi büyüt"
+	},
 	"tooltips": {
 		"hideHUD": "Kontrol panelini gizle",
 		"hideHUDTip": "Araç çubuğunu gizle. Bildirim alanındaki simgeden yeniden gösterebilirsiniz.",
diff --git a/src/i18n/locales/vi/launch.json b/src/i18n/locales/vi/launch.json
index 53f452e27..fe3ce29fa 100644
--- a/src/i18n/locales/vi/launch.json
+++ b/src/i18n/locales/vi/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "Xem trước camera",
+		"show": "Hiện bản xem trước camera",
+		"hide": "Ẩn bản xem trước camera",
+		"smaller": "Thu nhỏ bản xem trước",
+		"larger": "Phóng to bản xem trước"
+	},
 	"tooltips": {
 		"hideHUD": "Ẩn HUD",
 		"hideHUDTip": "Ẩn thanh ghi hình. Hiện lại từ biểu tượng ở khay hệ thống.",
diff --git a/src/i18n/locales/zh-CN/launch.json b/src/i18n/locales/zh-CN/launch.json
index a4bbf2c57..b53025f9c 100644
--- a/src/i18n/locales/zh-CN/launch.json
+++ b/src/i18n/locales/zh-CN/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "摄像头预览",
+		"show": "显示摄像头预览",
+		"hide": "隐藏摄像头预览",
+		"smaller": "缩小预览",
+		"larger": "放大预览"
+	},
 	"tooltips": {
 		"hideHUD": "隐藏录制栏",
 		"hideHUDTip": "隐藏录制栏，可通过系统托盘图标重新显示",
diff --git a/src/i18n/locales/zh-TW/launch.json b/src/i18n/locales/zh-TW/launch.json
index 2e460592e..03d134c20 100644
--- a/src/i18n/locales/zh-TW/launch.json
+++ b/src/i18n/locales/zh-TW/launch.json
@@ -1,4 +1,11 @@
 {
+	"floatingCamera": {
+		"title": "攝影機預覽",
+		"show": "顯示攝影機預覽",
+		"hide": "隱藏攝影機預覽",
+		"smaller": "縮小預覽",
+		"larger": "放大預覽"
+	},
 	"tooltips": {
 		"hideHUD": "隱藏控制面板",
 		"hideHUDTip": "隱藏控制面板。可從系統匣圖示重新顯示。",
diff --git a/src/lib/cameraPreview.test.ts b/src/lib/cameraPreview.test.ts
new file mode 100644
index 000000000..0a2ebd6b3
--- /dev/null
+++ b/src/lib/cameraPreview.test.ts
@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { cameraPreviewBounds, resizedCameraPreviewBounds } from "./cameraPreview";
+
+const workArea = { x: 0, y: 25, width: 1512, height: 900 };
+const bar = { x: 300, y: 840, width: 900, height: 64 };
+
+describe("camera preview placement", () => {
+	it("starts just above the recording bar's right end", () => {
+		const preview = cameraPreviewBounds(workArea, bar);
+		expect(preview.x + preview.width).toBe(bar.x + bar.width);
+		expect(preview.y + preview.height).toBe(bar.y - 8);
+	});
+
+	it("keeps the bottom centre fixed when resized near the bar", () => {
+		const before = cameraPreviewBounds(workArea, bar);
+		const after = resizedCameraPreviewBounds(before, workArea, 320);
+		expect(after.width).toBe(336);
+		expect(after.height).toBe(196);
+		expect(after.y + after.height).toBe(before.y + before.height);
+		expect(after.x + after.width / 2).toBe(before.x + before.width / 2);
+	});
+
+	it("preserves the full portrait, landscape and square frame at every preview size", () => {
+		for (const ratio of [9 / 16, 16 / 9, 1]) {
+			for (const width of [160, 224, 320]) {
+				const bounds = resizedCameraPreviewBounds(bar, workArea, width, ratio);
+				expect((bounds.width - 16) / (bounds.height - 16)).toBeCloseTo(ratio, 2);
+			}
+		}
+	});
+
+	it("keeps a preview on-screen on negative-origin displays and near the screen edge", () => {
+		const display = { x: -1280, y: -100, width: 1280, height: 720 };
+		const preview = resizedCameraPreviewBounds(
+			{ x: -1280, y: -100, width: 176, height: 176 },
+			display,
+			320,
+		);
+		expect(preview.x).toBeGreaterThanOrEqual(display.x);
+		expect(preview.y).toBeGreaterThanOrEqual(display.y);
+		expect(preview.x + preview.width).toBeLessThanOrEqual(0);
+		expect(preview.y + preview.height).toBeLessThanOrEqual(620);
+	});
+});
diff --git a/src/lib/cameraPreview.ts b/src/lib/cameraPreview.ts
new file mode 100644
index 000000000..8525b3247
--- /dev/null
+++ b/src/lib/cameraPreview.ts
@@ -0,0 +1,62 @@
+export const CAMERA_PREVIEW_SIZES = [160, 224, 320] as const;
+export const CAMERA_PREVIEW_DEFAULT_SIZE = 224;
+export const CAMERA_PREVIEW_DEFAULT_ASPECT_RATIO = 16 / 9;
+const WINDOW_PADDING = 16;
+
+type Rect = { x: number; y: number; width: number; height: number };
+
+function previewSize(width: number, aspectRatio: number, workArea: Rect) {
+	const contentWidth = Math.min(
+		width,
+		workArea.width - WINDOW_PADDING,
+		(workArea.height - WINDOW_PADDING) * aspectRatio,
+	);
+	return {
+		width: Math.round(contentWidth) + WINDOW_PADDING,
+		height: Math.round(contentWidth / aspectRatio) + WINDOW_PADDING,
+	};
+}
+
+function clampBounds(
+	x: number,
+	y: number,
+	size: { width: number; height: number },
+	workArea: Rect,
+): Rect {
+	return {
+		x: Math.round(Math.max(workArea.x, Math.min(x, workArea.x + workArea.width - size.width))),
+		y: Math.round(Math.max(workArea.y, Math.min(y, workArea.y + workArea.height - size.height))),
+		...size,
+	};
+}
+
+/** Place the complete camera frame just above the bar's right end. */
+export function cameraPreviewBounds(workArea: Rect, bar?: Rect): Rect {
+	const size = previewSize(
+		CAMERA_PREVIEW_DEFAULT_SIZE,
+		CAMERA_PREVIEW_DEFAULT_ASPECT_RATIO,
+		workArea,
+	);
+	return clampBounds(
+		bar ? bar.x + bar.width - size.width : workArea.x + workArea.width / 2 + 160,
+		(bar?.y ?? workArea.y + workArea.height - 84) - size.height - 8,
+		size,
+		workArea,
+	);
+}
+
+/** Resize without cropping, retaining the bottom centre and distance from the bar. */
+export function resizedCameraPreviewBounds(
+	bounds: Rect,
+	workArea: Rect,
+	width: number,
+	aspectRatio = CAMERA_PREVIEW_DEFAULT_ASPECT_RATIO,
+): Rect {
+	const size = previewSize(width, aspectRatio, workArea);
+	return clampBounds(
+		bounds.x + (bounds.width - size.width) / 2,
+		bounds.y + bounds.height - size.height,
+		size,
+		workArea,
+	);
+}
diff --git a/technical-documentation/architecture/recording.md b/technical-documentation/architecture/recording.md
index 2f643ec22..1396dd6ea 100644
--- a/technical-documentation/architecture/recording.md
+++ b/technical-documentation/architecture/recording.md
@@ -22,6 +22,20 @@ The HUD starts and controls a recording. The source selector chooses a display o
 
 Electron applies `setContentProtection(true)` to the HUD window (`applyContentProtection` in `electron/windows.ts`). This keeps the controller out of captures and also makes it invisible in screenshots. It is skipped on macOS 26 and later, which never displays a protected window, and on Windows before 11 22H2 (build 22621), where it leaves the click-through HUD unable to take a click (#1105). On those Windows versions the HUD can appear in recordings; on macOS the ScreenCaptureKit helper still excludes it by window id. For a testing session only, `OPENSCREEN_DISABLE_CONTENT_PROTECTION=1` disables the protection; the code warns that the HUD then appears in captures. The tray icon is the reliable way to refocus OpenScreen or stop a recording when the click-through HUD is not convenient or is not visible.
 
+## Presenter camera preview (macOS)
+
+The HUD camera has a draggable rounded rectangular self-view with show/hide and three width choices.
+It shows the complete camera frame at the shared recording stream’s aspect ratio, including when resized.
+Its preview button is hidden when the camera is off. The preview shares
+`useScreenRecorder`'s stream and stops with its owning HUD; it does not acquire another camera.
+`useFloatingCameraPreview` publishes small JPEG frames to the auxiliary window, with bounded
+payloads and one IPC request in flight. Audio preference broadcasts in the macOS HUD preserve
+its resolved camera selection so the preview does not blink when audio is toggled.
+
+Hiding or resizing retains the window id. macOS capture excludes that id alongside the HUD
+and Notes, including windows hidden when capture starts. This requires rebuilding the native
+helper. Windows and Linux keep their existing recording controls.
+
 ## Capture backends
 
 | Platform | Backend | Code | Produces |
diff --git a/technical-documentation/testing/manual-e2e-checklist.md b/technical-documentation/testing/manual-e2e-checklist.md
index 340df1480..01ba21023 100644
--- a/technical-documentation/testing/manual-e2e-checklist.md
+++ b/technical-documentation/testing/manual-e2e-checklist.md
@@ -994,3 +994,10 @@ These checks are the human slice: an agent cannot click Apple's picker (see abov
 | 2026-10-17 | PR #1319 (`2236580`), artifact `openscreen-linux` of build run 39046512213, AppImage run directly. Reference: the `v2.1.0` AppImage from the GitHub release | Ubuntu 24.04.4, GNOME 46 Wayland, AMD Radeon 610M (RADV); `[d3d] … -> backend Hardware`, no CPU fallback | **Partial — fix slice only, no defect** | Same MCP pass and project as the rows above, on the hardware Vulkan backend. `orbit` (12 frames) and `left` (4 s, 6 s): the whole card with four rounded corners, no flat cut. `v2.1.0` reproduces the bug (top and bottom edges flat, corners cut from 1.5 s). `none` and the flat frames at 1.0 and 9.5 s are byte-identical to `v2.1.0` (equal md5). **Not covered:** the editor preview; `right`; a full MP4 export. |
 | 2026-10-17 | `v2.1.1-rc.1`, `release/v2.1.1` @ `6ec38bf` (= `v2.1.0` + #1319), assets of the GitHub pre-release (build run 39069024444). Windows: `Openscreen.Setup.2.1.1-rc.1-x64.exe`, sha512 matched `latest.yml`, unpacked with 7-Zip and run in place, version 2.1.1. macOS: `Openscreen-macOS-Apple-Silicon-2.1.1-rc.1.dmg`, sha256 matched the asset digest; `spctl` accepted, Notarized Developer ID, on the DMG and the app; ticket stapled to the DMG only, as on 2.1.0-rc.6; `CFBundleShortVersionString` 2.1.1-rc.1. Linux: `Openscreen-Linux-2.1.1-rc.1.AppImage`, sha512 matched `latest-linux.yml` | Windows 11 Home 26200, RTX 4070 Ti; macOS 27.0.1 (26A434), Mac mini M1 8 GB; Ubuntu 24.04.4, GNOME 46 Wayland, Radeon 610M, hardware Vulkan backend | **Partial — patch pass toward stable: no defect on any of the three** | Scoped to what the patch changes (the compositor geometry of a tilted filled card), in MCP over stdio with an isolated `--user-data-dir`, on the project of the PR rows above. On all three: `orbit` (12 frames) and `left` show the whole card with four rounded corners and no flat cut; `none` is a flat zoom in a rounded card (byte-identical to `v2.1.0` on Windows and Linux; on Windows every checked frame is byte-identical to the PR build). `exportVideo` at 1080p30: 10.00 s, 1920×1080 H.264 with an AAC track, decodes without error, and its frame at 5 s shows the tilted card with rounded corners. Before the cut, on a dev build of the PR: the four device frames, dual-frame and vertical-stack, under `orbit`, `left` and `none`, rendered byte-identical to `v2.1.0` (49 of 49 frames). **Not covered:** recording, playback and the editor preview, which the patch does not touch; the rest of the checklist (the `v2.1.0-rc.6` rows). |
 | 2026-10-19 | `v2.1.2-rc.1`, `release/v2.1.2` @ `c4ef8fd` (= `v2.1.1` + #1344), assets of the GitHub pre-release (build run 39224311283). Windows: `Openscreen.Setup.2.1.2-rc.1-x64.exe` unpacked with 7-Zip and run in place. macOS: `Openscreen-Mac-arm64-2.1.2-rc.1.zip`, run in place. Linux: the AppImage, run directly with `--no-sandbox` | Windows 11 Home 26200; macOS 27.0.1, Mac mini M1; Ubuntu 24.04 GNOME Wayland (Xwayland `:0`) | **Partial: fix slice only, no defect** | `openscreen mcp` over stdio, scripted, with a fresh `--user-data-dir` per run. On all three platforms it answered `initialize`, and `usage-ping.json` held today's day, which is saved only once PostHog accepted the event. With `DO_NOT_TRACK=1` no state file was written. stdout held only JSON-RPC on macOS and Linux. On Windows it starts with one `\r\n` that Electron 41 itself writes during browser-process startup, before `main.js` loads: a bare `app.exit(0)` script prints it too, `ELECTRON_RUN_AS_NODE` does not. It predates this change, and the MCP SDK clients skip it with one parse error. Not covered: everything else in this file, including recording, editing, export, the GUI ping and the tray toggle. These runs sent eight real `surface: mcp` events to PostHog on 19/10. |
+| 2026-10-16 | dev `main` @ `b149c55` + #1278 macOS camera preview; Electron 41.2.1; capture helper built from the working tree with `swiftc` + macOS 26.5 SDK (SHA256 `06f142f075e4dd776b653f174379b2795a60d750557655f9bca6e2d2596c8f99`) | macOS 26.7, Apple Silicon, MacBook Pro Camera | **Partial — preview slice passed** | `mcp__cua_repl`: live circular self-view, show/hide during recording, three sizes and limit buttons, disabled preview button when camera is off, and recording finalization into screen MP4 + webcam WebM. Exercised OS dragging without independently measuring the final position. A take started with the preview hidden and showed it during capture; a decoded late screen frame contained no floating circle. Default placement and resize anchoring are covered by geometry tests. **Skipped:** Apple’s picker, fullscreen Spaces, other cameras, restart/cancel, export, exhaustive frame-by-frame exclusion, Windows/Linux and the remaining checklist. SwiftPM/XCTest unavailable locally; direct helper compilation passed. |
+
+| 2026-10-19 | dev `codex/macos-floating-camera-preview`, rebased on `main` @ `3620cf8`, plus #1288 review changes; Electron 41.2.1; native helper rebuilt directly with `swiftc` + macOS 26.5 SDK | macOS 26.7, Apple M5 Pro, MacBook Pro Camera | **Partial — preview review slice passed** | Computer-use verified the complete rounded rectangular camera frame, aspect-preserving resize, camera-off hiding the HUD preview control, and show/hide during a finalized camera take. In the same take, after 5 s settling per condition, 30 s process-tree CPU deltas were **17.5% hidden / 22.3% shown** (100%=one core; includes Electron children and capture helper). Native `recording-stopped` reported **0 droppedVideoFrames over the entire take**, covering both intervals; this counts screen-writer backpressure/append failures, not upstream capture or webcam drops. Screen 1 at 3024×1964, saved webcam verified 1920×1080 (30 fps requested); mic/system audio off, system cursor. One sequential pair, no statistical claim. **Skipped:** Apple’s picker, fullscreen Spaces, other cameras/platforms, restart/cancel, export, exhaustive exclusion and remaining checklist. |
+
+| 2026-10-19 | dev #1288 on `8c2608d9` + preview lifetime/quit fixes; Electron 41.2.1 | macOS 26.7, Apple Silicon, MacBook Pro Camera | **Partial — lifecycle slice passed** | Computer-use camera off/on removed/restored the HUD preview control. Normal Cmd+Q exited the OpenScreen Electron process with the preview enabled. Unit tests verify the same preview window survives initial camera-off and repeated toggles, with one owner-destruction listener and cleanup on HUD destruction. **Skipped:** recording, export, capture-exclusion measurements, other platforms and remaining checklist; no native capture changes in this slice. |
+
+| 2026-10-21 | dev #1288 on `20975d30` + synchronous preview reservation before capture exclusions; Electron 41.2.1; existing helper rebuilt from this branch on Oct 19 | macOS 26.7, Apple Silicon, MacBook Pro Camera | **Partial — capture-exclusion ordering slice passed** | Computer-use started native display recording with the preview hidden, showed it during the take and finalized into the editor. Helper diagnostics resolved both requested app window IDs and reported zero screen-writer drops; a decoded late screen frame contained no floating preview. Unit regression covers reserving the exclusion window before any renderer configuration and reusing it when enabled later without altering an existing preview’s visibility. **Skipped:** Apple’s picker (ordering path checked in code), forced renderer-effect race on desktop (covered by unit regression), other platforms, export, exhaustive frame-by-frame exclusion and remaining checklist. |