diff --git a/src/index.html b/src/index.html
index 04baf9c..bb0c571 100644
--- a/src/index.html
+++ b/src/index.html
@@ -212,6 +212,15 @@ <h2 class="text-xs font-medium text-neutral-500 uppercase tracking-wider mb-2">R
               id="cameraSource"
               class="w-full bg-neutral-900 border border-neutral-800 rounded-lg px-2.5 py-1.5 text-sm focus:outline-none focus:ring-1 focus:ring-neutral-600 transition-colors"
             ></select>
+            <label class="mt-1.5 flex items-center gap-2 text-xs text-neutral-400 cursor-pointer">
+              <input
+                type="checkbox"
+                id="cameraMirrorCheckbox"
+                class="accent-neutral-400"
+                checked
+              />
+              <span>Mirror camera</span>
+            </label>
           </div>
           <div>
             <label class="block text-xs font-medium text-neutral-500 uppercase tracking-wider mb-1"
diff --git a/src/main/services/premiere-export-service.ts b/src/main/services/premiere-export-service.ts
index 1276f50..1f5727c 100644
--- a/src/main/services/premiere-export-service.ts
+++ b/src/main/services/premiere-export-service.ts
@@ -48,6 +48,9 @@ export interface PremiereExportOptions {
   sourceWidth: number;
   sourceHeight: number;
   cameraSyncOffsetMs: number;
+  // Defaults to true to preserve historical selfie-mirror behavior when the
+  // caller has not yet plumbed the setting through.
+  cameraMirror?: boolean;
   takes: PremiereExportTakeInput[];
   sections: PremiereExportSectionInput[];
   keyframes: Keyframe[];
@@ -139,10 +142,13 @@ function buildCameraTranscodeArgs(
   inputPath: string,
   outputPath: string,
   cameraSyncOffsetMs: number,
-  includeAudio: boolean
+  includeAudio: boolean,
+  mirror: boolean
 ): string[] {
-  // Mirror horizontally only; preserve native dimensions so the user can
-  // expand / re-crop the full camera frame in Premiere.
+  // Preserve native dimensions so the user can expand / re-crop the full
+  // camera frame in Premiere. Horizontal mirroring is optional so projects
+  // that disable selfie-mirror do not get a flipped asset shipped to the
+  // NLE.
   const offsetSec = normalizeCameraSyncOffsetMs(cameraSyncOffsetMs) / 1000;
   const args = [
     '-progress',
@@ -154,7 +160,8 @@ function buildCameraTranscodeArgs(
   if (Math.abs(offsetSec) > 0.0005) {
     args.push('-itsoffset', (-offsetSec).toFixed(3));
   }
-  args.push('-i', inputPath, '-map', '0:v:0?', '-vf', 'hflip,setsar=1');
+  const videoFilter = mirror ? 'hflip,setsar=1' : 'setsar=1';
+  args.push('-i', inputPath, '-map', '0:v:0?', '-vf', videoFilter);
   if (includeAudio) {
     // Camera file owns the mic for this take; preserve it so Premiere can
     // import the PiP clip with its built-in audio track.
@@ -351,7 +358,8 @@ export async function exportPremiereProject(
         job.inputPath,
         job.outputPath,
         opts.cameraSyncOffsetMs,
-        job.includeCameraAudio === true
+        job.includeCameraAudio === true,
+        opts.cameraMirror !== false
       );
     } else {
       args = buildAudioTranscodeArgs(job.inputPath, job.outputPath);
diff --git a/src/main/services/preview-render-service.ts b/src/main/services/preview-render-service.ts
index 2117032..329a28b 100644
--- a/src/main/services/preview-render-service.ts
+++ b/src/main/services/preview-render-service.ts
@@ -62,6 +62,7 @@ export interface ComputeTimelineHashInput {
   cameraSyncOffsetMs: number;
   sourceWidth: number;
   sourceHeight: number;
+  cameraMirror?: boolean;
 }
 
 function round(value: unknown, digits = 3): number {
@@ -130,7 +131,11 @@ export function computeTimelineHash(input: ComputeTimelineHashInput): string {
     fit: input?.screenFitMode === 'fit' ? 'fit' : 'fill',
     camSync: Math.round(Number(input?.cameraSyncOffsetMs) || 0),
     w: Math.round(Number(input?.sourceWidth) || 0),
-    h: Math.round(Number(input?.sourceHeight) || 0)
+    h: Math.round(Number(input?.sourceHeight) || 0),
+    // Including the mirror flag in the hash ensures that toggling the
+    // camera orientation invalidates any cached preview so the next render
+    // actually reflects the new setting.
+    camMirror: input?.cameraMirror !== false
   };
 
   return crypto.createHash('sha256').update(JSON.stringify(payload)).digest('hex').slice(0, 16);
@@ -159,6 +164,7 @@ export interface GeneratePreviewOpts {
   cameraSyncOffsetMs: number;
   sourceWidth: number;
   sourceHeight: number;
+  cameraMirror?: boolean;
 }
 
 export interface GeneratePreviewResult {
@@ -213,6 +219,7 @@ export async function generatePreview(
       exportAudioPreset,
       exportVideoPreset,
       cameraSyncOffsetMs: opts.cameraSyncOffsetMs,
+      cameraMirror: opts.cameraMirror,
       sourceWidth: opts.sourceWidth,
       sourceHeight: opts.sourceHeight,
       outputPath: previewPath
diff --git a/src/main/services/render-filter-service.ts b/src/main/services/render-filter-service.ts
index bc2d28e..59af9f1 100644
--- a/src/main/services/render-filter-service.ts
+++ b/src/main/services/render-filter-service.ts
@@ -248,7 +248,8 @@ export function buildFilterComplex(
   sourceHeight: number,
   canvasW: number,
   canvasH: number,
-  targetFps = 30
+  targetFps = 30,
+  cameraMirror = true
 ): string {
   const { outW, outH } = resolveOutputSize(canvasW, canvasH);
   const scaleX = outW / AUTHORING_CANVAS_W;
@@ -282,6 +283,11 @@ export function buildFilterComplex(
   const hasPip = keyframes.some((keyframe) => keyframe.pipVisible);
   const hasCamFull = keyframes.some((keyframe) => keyframe.cameraFullscreen);
 
+  // Only emit hflip when the project wants the camera mirrored. Dropping the
+  // filter entirely (vs. letting it be a no-op) keeps the filter graph a hair
+  // simpler and makes the intent clear when inspecting the ffmpeg command.
+  const mirrorChain = cameraMirror ? ',hflip' : '';
+
   if (hasPip && hasCamFull) {
     const alphaExpr = buildAlphaExpr(keyframes);
     const roundCornerExpr = `lte(pow(max(0,max(${radius}-X,X-${maxCoord})),2)+pow(max(0,max(${radius}-Y,Y-${maxCoord})),2),${radiusSquared})`;
@@ -293,18 +299,18 @@ export function buildFilterComplex(
     const xExpr = buildPosExpr(scaledKeyframes, 'pipX');
     const yExpr = buildPosExpr(scaledKeyframes, 'pipY');
 
-    return `${screenFilter};[1:v]setpts=PTS-STARTPTS,hflip,split[cam1][cam2];${camPipFilter};${camFullFilter};[screen][cam]overlay=x='${xExpr}':y='${yExpr}':format=auto[with_pip];[with_pip][camfull]overlay=0:0:format=auto[out]`;
+    return `${screenFilter};[1:v]setpts=PTS-STARTPTS${mirrorChain},split[cam1][cam2];${camPipFilter};${camFullFilter};[screen][cam]overlay=x='${xExpr}':y='${yExpr}':format=auto[with_pip];[with_pip][camfull]overlay=0:0:format=auto[out]`;
   }
 
   if (hasCamFull) {
     const camFullAlpha = buildCamFullAlphaExpr(keyframes);
-    const camFullFilter = `[1:v]setpts=PTS-STARTPTS,hflip,scale=${outW}:${outH}:flags=lanczos:force_original_aspect_ratio=increase,crop=${outW}:${outH},format=yuva420p,geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='255*(${camFullAlpha})'[camfull]`;
+    const camFullFilter = `[1:v]setpts=PTS-STARTPTS${mirrorChain},scale=${outW}:${outH}:flags=lanczos:force_original_aspect_ratio=increase,crop=${outW}:${outH},format=yuva420p,geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='255*(${camFullAlpha})'[camfull]`;
     return `${screenFilter};${camFullFilter};[screen][camfull]overlay=0:0:format=auto[out]`;
   }
 
   const alphaExpr = buildAlphaExpr(keyframes);
   const roundCornerExpr = `lte(pow(max(0,max(${radius}-X,X-${maxCoord})),2)+pow(max(0,max(${radius}-Y,Y-${maxCoord})),2),${radiusSquared})`;
-  const camFilter = `[1:v]setpts=PTS-STARTPTS,hflip,crop='min(iw,ih)':'min(iw,ih)':'(iw-min(iw,ih))/2':'(ih-min(iw,ih))/2',scale=${actualPipSize}:${actualPipSize},format=yuva420p,geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='255*${roundCornerExpr}*(${alphaExpr})'[cam]`;
+  const camFilter = `[1:v]setpts=PTS-STARTPTS${mirrorChain},crop='min(iw,ih)':'min(iw,ih)':'(iw-min(iw,ih))/2':'(ih-min(iw,ih))/2',scale=${actualPipSize}:${actualPipSize},format=yuva420p,geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='255*${roundCornerExpr}*(${alphaExpr})'[cam]`;
 
   const xExpr = buildPosExpr(scaledKeyframes, 'pipX');
   const yExpr = buildPosExpr(scaledKeyframes, 'pipY');
diff --git a/src/main/services/render-service.ts b/src/main/services/render-service.ts
index 5426dfb..ae1ccc0 100644
--- a/src/main/services/render-service.ts
+++ b/src/main/services/render-service.ts
@@ -59,6 +59,10 @@ export interface RenderCompositeOptions {
   exportAudioPreset?: ExportAudioPreset;
   exportVideoPreset?: ExportVideoPreset;
   cameraSyncOffsetMs?: number;
+  // Whether the camera should be mirrored horizontally in the composite.
+  // Defaults to true to preserve historical behavior for legacy callers that
+  // do not plumb this option through.
+  cameraMirror?: boolean;
   sourceWidth?: number;
   sourceHeight?: number;
   outputFolder?: string;
@@ -574,6 +578,7 @@ export async function renderComposite(
   const keyframes = Array.isArray(opts.keyframes) ? opts.keyframes : [];
   const pipSize = Number.isFinite(Number(opts.pipSize)) ? Number(opts.pipSize) : 422;
   const screenFitMode = opts.screenFitMode === 'fit' ? 'fit' : 'fill';
+  const cameraMirror = opts.cameraMirror !== false;
   const exportAudioPreset = normalizeExportAudioPreset(opts.exportAudioPreset);
   const exportVideoPreset = normalizeExportVideoPreset(opts.exportVideoPreset);
   const cameraSyncOffsetMs = normalizeCameraSyncOffsetMs(opts.cameraSyncOffsetMs);
@@ -813,7 +818,8 @@ export async function renderComposite(
       sourceHeight,
       canvasW,
       canvasH,
-      targetFps
+      targetFps,
+      cameraMirror
     );
     assertOverlayFilterSize(overlayFilter);
     const adaptedOverlay = overlayFilter
diff --git a/src/renderer/app.ts b/src/renderer/app.ts
index b2aa5d2..909841d 100644
--- a/src/renderer/app.ts
+++ b/src/renderer/app.ts
@@ -42,7 +42,7 @@ import {
   createScreenRecordingStream
 } from './features/recording/recorder-utils';
 import { resolveTakeAudio } from '../shared/domain/take-audio';
-import { drawMirroredImage, getCenteredSquareCropRect } from './features/camera/camera-render';
+import { drawCameraImage, getCenteredSquareCropRect } from './features/camera/camera-render';
 import { cleanupAllMedia } from './features/media-cleanup';
 
 const projectHomeView = document.getElementById('projectHomeView');
@@ -72,6 +72,7 @@ const screenSelect = document.getElementById('screenSource');
 const screenFitSelect = document.getElementById('screenFit');
 const systemAudioCheckbox = document.getElementById('systemAudioCheckbox');
 const cameraSelect = document.getElementById('cameraSource');
+const cameraMirrorCheckbox = document.getElementById('cameraMirrorCheckbox');
 const audioSelect = document.getElementById('audioSource');
 const canvas = document.getElementById('compositeCanvas');
 const ctx = canvas.getContext('2d');
@@ -906,7 +907,8 @@ function buildProjectSavePayload() {
       exportVideoPreset: normalizeExportVideoPreset(exportVideoPresetSelect.value),
       cameraSyncOffsetMs: normalizeCameraSyncOffsetMs(cameraSyncOffsetInput.value),
       pipSize: editorState?.pipSize || PIP_SIZE,
-      systemAudioEnabled: !!systemAudioCheckbox?.checked
+      systemAudioEnabled: !!systemAudioCheckbox?.checked,
+      cameraMirror: cameraMirrorCheckbox ? cameraMirrorCheckbox.checked : true
     },
     timeline: getProjectTimelineSnapshot()
   };
@@ -1082,6 +1084,7 @@ function buildPreviewInputs() {
     pipSize: editorState.pipSize,
     screenFitMode: editorState.screenFitMode,
     cameraSyncOffsetMs: editorState.cameraSyncOffsetMs,
+    cameraMirror: editorState.cameraMirror !== false,
     sourceWidth: editorState.sourceWidth || CANVAS_W,
     sourceHeight: editorState.sourceHeight || CANVAS_H
   };
@@ -1125,7 +1128,8 @@ function schedulePreviewRender() {
         fit: inputs.screenFitMode === 'fit' ? 'fit' : 'fill',
         camSync: Math.round(inputs.cameraSyncOffsetMs || 0),
         w: Math.round(inputs.sourceWidth || 0),
-        h: Math.round(inputs.sourceHeight || 0)
+        h: Math.round(inputs.sourceHeight || 0),
+        camMirror: inputs.cameraMirror !== false
       });
       const buffer = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(payload));
       const hex = Array.from(new Uint8Array(buffer))
@@ -1149,6 +1153,7 @@ function schedulePreviewRender() {
         pipSize: inputs.pipSize,
         screenFitMode: inputs.screenFitMode,
         cameraSyncOffsetMs: inputs.cameraSyncOffsetMs,
+        cameraMirror: inputs.cameraMirror !== false,
         sourceWidth: inputs.sourceWidth,
         sourceHeight: inputs.sourceHeight
       });
@@ -1334,6 +1339,12 @@ async function activateProject(projectPath, project, preferredView = 'recording'
   if (systemAudioCheckbox) {
     systemAudioCheckbox.checked = project.settings?.systemAudioEnabled === true;
   }
+  if (cameraMirrorCheckbox) {
+    // cameraMirror defaults to true so legacy projects that never stored the
+    // flag keep the historical selfie-mirror behavior. Only an explicit false
+    // flips the checkbox off.
+    cameraMirrorCheckbox.checked = project.settings?.cameraMirror !== false;
+  }
   exportAudioPresetSelect.value = normalizeExportAudioPreset(project.settings?.exportAudioPreset);
   exportVideoPresetSelect.value = normalizeExportVideoPreset(project.settings?.exportVideoPreset);
   cameraSyncOffsetInput.value = String(
@@ -1354,6 +1365,7 @@ async function activateProject(projectPath, project, preferredView = 'recording'
       sourceWidth: project.timeline.sourceWidth || null,
       sourceHeight: project.timeline.sourceHeight || null,
       cameraSyncOffsetMs: project.settings?.cameraSyncOffsetMs,
+      cameraMirror: project.settings?.cameraMirror !== false,
       initialView: preferredView === 'recording' ? 'recording' : 'timeline'
     });
   } else {
@@ -2170,7 +2182,7 @@ function getRenderSections() {
 }
 
 // ===== Shared drawPip function =====
-function drawPip(targetCtx, video, pipX, pipY, pipW, pipH) {
+function drawPip(targetCtx, video, pipX, pipY, pipW, pipH, mirror = true) {
   const r = 12;
   targetCtx.save();
   targetCtx.beginPath();
@@ -2192,7 +2204,7 @@ function drawPip(targetCtx, video, pipX, pipY, pipW, pipH) {
     targetCtx.restore();
     return;
   }
-  drawMirroredImage(
+  drawCameraImage(
     targetCtx,
     video,
     crop.sourceX,
@@ -2202,12 +2214,13 @@ function drawPip(targetCtx, video, pipX, pipY, pipW, pipH) {
     pipX,
     pipY,
     pipW,
-    pipH
+    pipH,
+    mirror
   );
   targetCtx.restore();
 }
 
-function drawCameraRect(targetCtx, video, x, y, w, h, r) {
+function drawCameraRect(targetCtx, video, x, y, w, h, r, mirror = true) {
   const vw = video.videoWidth;
   const vh = video.videoHeight;
   if (!vw || !vh) return;
@@ -2233,7 +2246,7 @@ function drawCameraRect(targetCtx, video, x, y, w, h, r) {
   const dh = vh * scale;
   const dx = x + (w - dw) / 2;
   const dy = y + (h - dh) / 2;
-  drawMirroredImage(targetCtx, video, 0, 0, vw, vh, dx, dy, dw, dh);
+  drawCameraImage(targetCtx, video, 0, 0, vw, vh, dx, dy, dw, dh, mirror);
   targetCtx.restore();
 }
 
@@ -2437,17 +2450,19 @@ function drawComposite(now = performance.now()) {
 
   const drawScreen = screenFitSelect.value === 'fill' ? drawFill : drawFit;
 
+  const mirrorCamera = cameraMirrorCheckbox ? cameraMirrorCheckbox.checked : true;
+
   if (hasScreen && hasCamera) {
     drawScreen(ctx, screenVideo, 0, 0, CANVAS_W, CANVAS_H);
     const pipW = PIP_SIZE;
     const pipH = pipW;
     const pipX = CANVAS_W - pipW - PIP_MARGIN;
     const pipY = CANVAS_H - pipH - PIP_MARGIN;
-    drawPip(ctx, cameraVideo, pipX, pipY, pipW, pipH);
+    drawPip(ctx, cameraVideo, pipX, pipY, pipW, pipH, mirrorCamera);
   } else if (hasScreen) {
     drawScreen(ctx, screenVideo, 0, 0, CANVAS_W, CANVAS_H);
   } else if (hasCamera) {
-    drawFit(ctx, cameraVideo, 0, 0, CANVAS_W, CANVAS_H);
+    drawFit(ctx, cameraVideo, 0, 0, CANVAS_W, CANVAS_H, mirrorCamera);
   }
 
   drawRAF = requestAnimationFrame(drawComposite);
@@ -2461,7 +2476,7 @@ function getSourceHeight(source) {
   return source.videoHeight || source.naturalHeight || source.height || 0;
 }
 
-function drawFit(targetCtx, video, x, y, w, h) {
+function drawFit(targetCtx, video, x, y, w, h, mirror = false) {
   const vw = getSourceWidth(video);
   const vh = getSourceHeight(video);
   if (!vw || !vh) return;
@@ -2470,7 +2485,7 @@ function drawFit(targetCtx, video, x, y, w, h) {
   const dh = vh * scale;
   const dx = x + (w - dw) / 2;
   const dy = y + (h - dh) / 2;
-  targetCtx.drawImage(video, dx, dy, dw, dh);
+  drawCameraImage(targetCtx, video, 0, 0, vw, vh, dx, dy, dw, dh, mirror);
 }
 
 function drawFill(targetCtx, video, x, y, w, h) {
@@ -4218,6 +4233,12 @@ function enterEditor(rawSections, opts = {}) {
     renderProgress: 0,
     playbackSpeed: 1,
     cameraSyncOffsetMs: normalizeCameraSyncOffsetMs(opts.cameraSyncOffsetMs),
+    cameraMirror:
+      typeof opts.cameraMirror === 'boolean'
+        ? opts.cameraMirror
+        : cameraMirrorCheckbox
+          ? cameraMirrorCheckbox.checked
+          : true,
     hasCamera: typeof opts.hasCamera === 'boolean' ? opts.hasCamera : false,
     sourceWidth: opts.sourceWidth || null,
     sourceHeight: opts.sourceHeight || null
@@ -4775,6 +4796,7 @@ function editorDrawLoop() {
   }
 
   if (hasCamera) {
+    const mirrorCamera = editorState.cameraMirror !== false;
     if (state.camTransition > 0 && state.opacity > 0) {
       editorCtx.save();
       if (state.opacity < 1) editorCtx.globalAlpha = state.opacity;
@@ -4784,7 +4806,7 @@ function editorDrawLoop() {
       const camW = editorState.pipSize + (CANVAS_W - editorState.pipSize) * t;
       const camH = editorState.pipSize + (CANVAS_H - editorState.pipSize) * t;
       const camR = 12 * (1 - t);
-      drawCameraRect(editorCtx, activeVideos.camera, camX, camY, camW, camH, camR);
+      drawCameraRect(editorCtx, activeVideos.camera, camX, camY, camW, camH, camR, mirrorCamera);
       editorCtx.restore();
     } else if (state.opacity > 0) {
       editorCtx.save();
@@ -4795,7 +4817,8 @@ function editorDrawLoop() {
         state.pipX,
         state.pipY,
         editorState.pipSize,
-        editorState.pipSize
+        editorState.pipSize,
+        mirrorCamera
       );
       editorCtx.restore();
     }
@@ -5435,6 +5458,7 @@ async function renderVideo() {
       exportAudioPreset: normalizeExportAudioPreset(exportAudioPresetSelect.value),
       exportVideoPreset: normalizeExportVideoPreset(exportVideoPresetSelect.value),
       cameraSyncOffsetMs: editorState.cameraSyncOffsetMs,
+      cameraMirror: editorState.cameraMirror !== false,
       sourceWidth: editorState.sourceWidth || CANVAS_W,
       sourceHeight: editorState.sourceHeight || CANVAS_H,
       outputFolder: saveFolder
@@ -5550,6 +5574,7 @@ async function exportPremiere() {
       sourceWidth: editorState.sourceWidth || CANVAS_W,
       sourceHeight: editorState.sourceHeight || CANVAS_H,
       cameraSyncOffsetMs: editorState.cameraSyncOffsetMs,
+      cameraMirror: editorState.cameraMirror !== false,
       takes,
       sections: premiereSections,
       keyframes: getRenderKeyframes()
@@ -5764,6 +5789,29 @@ screenFitSelect.addEventListener('change', () => {
   scheduleProjectSave();
 });
 
+if (cameraMirrorCheckbox) {
+  cameraMirrorCheckbox.addEventListener('change', () => {
+    const mirror = !!cameraMirrorCheckbox.checked;
+    if (activeProject?.settings) {
+      activeProject.settings.cameraMirror = mirror;
+    }
+    if (editorState) {
+      editorState.cameraMirror = mirror;
+      // Force editor preview to repaint with the new orientation and
+      // invalidate the cached preview so the next scheduled render does not
+      // reuse a previously mirrored (or un-mirrored) clip.
+      invalidatePreviewCache();
+      try {
+        editorSeek(editorState.currentTime);
+      } catch (_e) {
+        // editor may not be mounted yet; the next updatePreview() is enough.
+      }
+    }
+    updatePreview();
+    scheduleProjectSave();
+  });
+}
+
 screenSelect.addEventListener('change', async () => {
   try {
     await updateScreenStream();
diff --git a/src/renderer/features/camera/camera-render.ts b/src/renderer/features/camera/camera-render.ts
index 3d7013b..f7baeab 100644
--- a/src/renderer/features/camera/camera-render.ts
+++ b/src/renderer/features/camera/camera-render.ts
@@ -42,19 +42,66 @@ export function drawMirroredImage(
   destWidth: number,
   destHeight: number
 ): void {
-  targetCtx.save();
-  targetCtx.translate(destX + destWidth, destY);
-  targetCtx.scale(-1, 1);
-  targetCtx.drawImage(
+  drawCameraImage(
+    targetCtx,
     source,
     sourceX,
     sourceY,
     sourceWidth,
     sourceHeight,
-    0,
-    0,
+    destX,
+    destY,
     destWidth,
-    destHeight
+    destHeight,
+    true
   );
+}
+
+// Draws a camera frame, optionally mirrored horizontally (selfie view).
+// When `mirror` is false, the frame is drawn natively so on-screen text on
+// the presenter's side (e.g. a shirt logo) reads correctly. The save/restore
+// pair is preserved in both paths so callers that set up clipping before
+// calling this helper do not leak transform state.
+export function drawCameraImage(
+  targetCtx: MirrorDrawContext,
+  source: CanvasImageSource,
+  sourceX: number,
+  sourceY: number,
+  sourceWidth: number,
+  sourceHeight: number,
+  destX: number,
+  destY: number,
+  destWidth: number,
+  destHeight: number,
+  mirror: boolean
+): void {
+  targetCtx.save();
+  if (mirror) {
+    targetCtx.translate(destX + destWidth, destY);
+    targetCtx.scale(-1, 1);
+    targetCtx.drawImage(
+      source,
+      sourceX,
+      sourceY,
+      sourceWidth,
+      sourceHeight,
+      0,
+      0,
+      destWidth,
+      destHeight
+    );
+  } else {
+    targetCtx.drawImage(
+      source,
+      sourceX,
+      sourceY,
+      sourceWidth,
+      sourceHeight,
+      destX,
+      destY,
+      destWidth,
+      destHeight
+    );
+  }
   targetCtx.restore();
 }
diff --git a/src/shared/domain/project.ts b/src/shared/domain/project.ts
index b47d806..f37acbd 100644
--- a/src/shared/domain/project.ts
+++ b/src/shared/domain/project.ts
@@ -72,6 +72,12 @@ export interface ProjectSettings {
   // screen video. Sticky per project so toggling during editing does not
   // silently disable system audio on the next recording.
   systemAudioEnabled: boolean;
+  // Whether the camera is mirrored horizontally (selfie-style) everywhere the
+  // camera is shown: live preview, timeline preview render, final render, and
+  // Premiere export. Defaults to true to preserve the historical behavior of
+  // the app, where webcam previews always mirrored so on-screen text matched
+  // the presenter's intent.
+  cameraMirror: boolean;
 }
 
 export type AudioSource = 'screen' | 'camera' | 'external';
@@ -340,7 +346,8 @@ export function createDefaultProject(name: unknown = 'Untitled Project'): Projec
       exportVideoPreset: EXPORT_VIDEO_PRESET_QUALITY,
       cameraSyncOffsetMs: 0,
       pipSize: DEFAULT_PIP_SIZE,
-      systemAudioEnabled: false
+      systemAudioEnabled: false,
+      cameraMirror: true
     },
     takes: [],
     timeline: {
@@ -384,7 +391,8 @@ export function normalizeProjectData(rawProject: unknown, projectFolder?: string
       exportVideoPreset: normalizeExportVideoPreset(rawSettings.exportVideoPreset),
       cameraSyncOffsetMs: normalizeCameraSyncOffsetMs(rawSettings.cameraSyncOffsetMs),
       pipSize: normalizePipSize(rawSettings.pipSize),
-      systemAudioEnabled: rawSettings.systemAudioEnabled === true
+      systemAudioEnabled: rawSettings.systemAudioEnabled === true,
+      cameraMirror: rawSettings.cameraMirror !== false
     },
     takes: rawTakes.map((rawTake, index) => {
       const take = isRecord(rawTake) ? (rawTake as PartialTakeInput) : ({} as PartialTakeInput);
diff --git a/tests/integration/premiere-export-service.test.ts b/tests/integration/premiere-export-service.test.ts
index e9e0916..9708a6b 100644
--- a/tests/integration/premiere-export-service.test.ts
+++ b/tests/integration/premiere-export-service.test.ts
@@ -227,6 +227,34 @@ describe('main/services/premiere-export-service', () => {
     expect(updates.some((u) => u.phase === 'finalizing' && u.percent === 1)).toBe(true);
   });
 
+  test('exportPremiereProject omits hflip from camera transcode when cameraMirror is false', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'premiere-export-nomirror-'));
+    const calls: FfmpegCall[] = [];
+    const opts = makeBaseOpts(tmpDir, { cameraMirror: false });
+
+    await exportPremiereProject(opts, {
+      ffmpegPath: '/usr/bin/ffmpeg',
+      probeVideoFpsWithFfmpeg: async () => 30,
+      probeVideoDimensionsWithFfmpeg: async () => ({ width: 1920, height: 1080 }),
+      runFfmpeg: createRunFfmpegStub(calls, (call) => {
+        const outPath = call.args[call.args.length - 1];
+        if (outPath && outPath.endsWith('.mov')) {
+          fs.mkdirSync(path.dirname(outPath), { recursive: true });
+          fs.writeFileSync(outPath, 'prores-data', 'utf8');
+        }
+      })
+    });
+
+    const cameraCall = calls.find((c) => c.args.join(' ').includes('camera-take-1.mov'));
+    expect(cameraCall).toBeDefined();
+    const joined = cameraCall!.args.join(' ');
+    // hflip must be absent when the project disables selfie-mirror, otherwise
+    // the Premiere-ready asset ships flipped contrary to the user's choice.
+    expect(joined).not.toContain('hflip');
+    // setsar=1 is still applied so downstream NLE sample aspect ratio is sane.
+    expect(joined).toContain('setsar=1');
+  });
+
   test('exportPremiereProject dedupes ffmpeg jobs for repeated takes across sections', async () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'premiere-export-dedupe-'));
     const calls: FfmpegCall[] = [];
diff --git a/tests/unit/camera-render.test.ts b/tests/unit/camera-render.test.ts
index f8d7eaf..7060319 100644
--- a/tests/unit/camera-render.test.ts
+++ b/tests/unit/camera-render.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, test } from 'vitest';
 
 import {
+  drawCameraImage,
   drawMirroredImage,
   getCenteredSquareCropRect
 } from '../../src/renderer/features/camera/camera-render';
@@ -44,4 +45,49 @@ describe('renderer/features/camera/camera-render', () => {
       { name: 'restore', args: [] }
     ]);
   });
+
+  test('drawCameraImage with mirror=false draws natively without scale(-1,1)', () => {
+    const calls: Array<{ name: string; args: unknown[] }> = [];
+    const targetCtx = {
+      save: () => calls.push({ name: 'save', args: [] }),
+      translate: (...args: unknown[]) => calls.push({ name: 'translate', args }),
+      scale: (...args: unknown[]) => calls.push({ name: 'scale', args }),
+      drawImage: (...args: unknown[]) => calls.push({ name: 'drawImage', args }),
+      restore: () => calls.push({ name: 'restore', args: [] })
+    } as unknown as Pick<
+      CanvasRenderingContext2D,
+      'drawImage' | 'restore' | 'save' | 'scale' | 'translate'
+    >;
+    const source = { id: 'camera' } as unknown as CanvasImageSource;
+
+    drawCameraImage(targetCtx, source, 10, 20, 300, 200, 100, 150, 320, 180, false);
+
+    expect(calls).toEqual([
+      { name: 'save', args: [] },
+      { name: 'drawImage', args: [source, 10, 20, 300, 200, 100, 150, 320, 180] },
+      { name: 'restore', args: [] }
+    ]);
+  });
+
+  test('drawCameraImage with mirror=true matches drawMirroredImage exactly', () => {
+    const mirroredCalls: Array<{ name: string; args: unknown[] }> = [];
+    const nativeCalls: Array<{ name: string; args: unknown[] }> = [];
+    const mkCtx = (calls: Array<{ name: string; args: unknown[] }>) =>
+      ({
+        save: () => calls.push({ name: 'save', args: [] }),
+        translate: (...args: unknown[]) => calls.push({ name: 'translate', args }),
+        scale: (...args: unknown[]) => calls.push({ name: 'scale', args }),
+        drawImage: (...args: unknown[]) => calls.push({ name: 'drawImage', args }),
+        restore: () => calls.push({ name: 'restore', args: [] })
+      }) as unknown as Pick<
+        CanvasRenderingContext2D,
+        'drawImage' | 'restore' | 'save' | 'scale' | 'translate'
+      >;
+    const source = { id: 'camera' } as unknown as CanvasImageSource;
+
+    drawMirroredImage(mkCtx(mirroredCalls), source, 10, 20, 300, 200, 100, 150, 320, 180);
+    drawCameraImage(mkCtx(nativeCalls), source, 10, 20, 300, 200, 100, 150, 320, 180, true);
+
+    expect(mirroredCalls).toEqual(nativeCalls);
+  });
 });
diff --git a/tests/unit/preview-render-service.test.ts b/tests/unit/preview-render-service.test.ts
index 4efc4d7..26ffa35 100644
--- a/tests/unit/preview-render-service.test.ts
+++ b/tests/unit/preview-render-service.test.ts
@@ -107,6 +107,18 @@ describe('main/services/preview-render-service', () => {
       expect(computeTimelineHash(newerScreen)).not.toBe(computeTimelineHash(base));
     });
 
+    test('changes when cameraMirror toggles so a cached preview is invalidated', () => {
+      const base = defaultHashInput();
+      const unmirrored = { ...base, cameraMirror: false };
+      expect(computeTimelineHash(unmirrored)).not.toBe(computeTimelineHash(base));
+    });
+
+    test('omitting cameraMirror matches cameraMirror:true (legacy default)', () => {
+      const base = defaultHashInput();
+      const explicit = { ...base, cameraMirror: true };
+      expect(computeTimelineHash(base)).toBe(computeTimelineHash(explicit));
+    });
+
     test('is 16 hex characters long regardless of input size', () => {
       const short = computeTimelineHash(defaultHashInput());
       const big = computeTimelineHash({
@@ -217,6 +229,41 @@ describe('main/services/preview-render-service', () => {
 
       fs.rmSync(dir, { recursive: true, force: true });
     });
+
+    test('forwards cameraMirror to renderComposite so the preview matches the project setting', async () => {
+      const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'preview-mirror-'));
+      const hash = 'mirrorhashonef00';
+      const previewPath = derivePreviewPath(dir, hash);
+
+      const received: Array<Record<string, unknown>> = [];
+      await generatePreview(
+        {
+          projectFolder: dir,
+          timelineHash: hash,
+          takes: [],
+          sections: [{ takeId: 'take-1', sourceStart: 0, sourceEnd: 1 }],
+          keyframes: [],
+          pipSize: 400,
+          screenFitMode: 'fill',
+          cameraSyncOffsetMs: 0,
+          sourceWidth: 1920,
+          sourceHeight: 1080,
+          cameraMirror: false
+        },
+        {
+          renderComposite: (async (opts: Record<string, unknown>) => {
+            received.push(opts);
+            fs.writeFileSync(previewPath, 'rendered', 'utf8');
+            return previewPath;
+          }) as unknown as typeof import('../../src/main/services/render-service').renderComposite
+        }
+      );
+
+      expect(received).toHaveLength(1);
+      expect(received[0].cameraMirror).toBe(false);
+
+      fs.rmSync(dir, { recursive: true, force: true });
+    });
   });
 
   describe('cleanupStalePreviews', () => {
diff --git a/tests/unit/project-domain.test.ts b/tests/unit/project-domain.test.ts
index c2cc3b6..7984340 100644
--- a/tests/unit/project-domain.test.ts
+++ b/tests/unit/project-domain.test.ts
@@ -206,6 +206,32 @@ describe('shared/domain/project', () => {
     expect(normalizePipSize(600.6)).toBe(601);
   });
 
+  test('cameraMirror defaults to true and tolerates only an explicit false to disable', () => {
+    expect(createDefaultProject('Demo').settings.cameraMirror).toBe(true);
+
+    const missing = normalizeProjectData({ settings: {} }, '/tmp/proj');
+    expect(missing.settings.cameraMirror).toBe(true);
+
+    const disabled = normalizeProjectData(
+      { settings: { cameraMirror: false } },
+      '/tmp/proj'
+    );
+    expect(disabled.settings.cameraMirror).toBe(false);
+
+    // Any value other than an explicit boolean false keeps the historical
+    // mirrored behavior so existing projects do not silently un-mirror.
+    const truthy = normalizeProjectData(
+      { settings: { cameraMirror: 'yes' as unknown as boolean } },
+      '/tmp/proj'
+    );
+    const nullish = normalizeProjectData(
+      { settings: { cameraMirror: null as unknown as boolean } },
+      '/tmp/proj'
+    );
+    expect(truthy.settings.cameraMirror).toBe(true);
+    expect(nullish.settings.cameraMirror).toBe(true);
+  });
+
   test('normalizeProjectData preserves valid pipSize and defaults invalid values', () => {
     const sized = normalizeProjectData({ settings: { pipSize: 500 } }, '/tmp/proj');
     const fallback = normalizeProjectData({ settings: { pipSize: 'huge' } }, '/tmp/proj');
diff --git a/tests/unit/render-filter-service.test.ts b/tests/unit/render-filter-service.test.ts
index 168b8a2..92bbb3f 100644
--- a/tests/unit/render-filter-service.test.ts
+++ b/tests/unit/render-filter-service.test.ts
@@ -169,6 +169,97 @@ describe('main/services/render-filter-service', () => {
     expect(filter).toContain('[with_pip][camfull]overlay=0:0:format=auto[out]');
   });
 
+  test('buildFilterComplex omits hflip when cameraMirror is false (PiP only)', () => {
+    const filter = buildFilterComplex(
+      [
+        {
+          time: 0,
+          pipX: 100,
+          pipY: 100,
+          pipVisible: true,
+          cameraFullscreen: false,
+          backgroundZoom: 1,
+          backgroundPanX: 0,
+          backgroundPanY: 0
+        }
+      ] as Keyframe[],
+      320,
+      'fill',
+      1920,
+      1080,
+      1920,
+      1080,
+      30,
+      false
+    );
+    expect(filter).toContain('[1:v]setpts=PTS-STARTPTS,crop=');
+    expect(filter).not.toContain('hflip');
+  });
+
+  test('buildFilterComplex omits hflip when cameraMirror is false (fullscreen + PiP)', () => {
+    const filter = buildFilterComplex(
+      [
+        {
+          time: 0,
+          pipX: 100,
+          pipY: 100,
+          pipVisible: true,
+          cameraFullscreen: false,
+          backgroundZoom: 1,
+          backgroundPanX: 0,
+          backgroundPanY: 0
+        },
+        {
+          time: 2,
+          pipX: 120,
+          pipY: 120,
+          pipVisible: true,
+          cameraFullscreen: true,
+          backgroundZoom: 1,
+          backgroundPanX: 0,
+          backgroundPanY: 0
+        }
+      ] as Keyframe[],
+      320,
+      'fill',
+      1920,
+      1080,
+      1920,
+      1080,
+      30,
+      false
+    );
+    expect(filter).toContain('[1:v]setpts=PTS-STARTPTS,split[cam1][cam2]');
+    expect(filter).not.toContain('hflip');
+  });
+
+  test('buildFilterComplex omits hflip when cameraMirror is false (fullscreen only)', () => {
+    const filter = buildFilterComplex(
+      [
+        {
+          time: 0,
+          pipX: 100,
+          pipY: 100,
+          pipVisible: false,
+          cameraFullscreen: true,
+          backgroundZoom: 1,
+          backgroundPanX: 0,
+          backgroundPanY: 0
+        }
+      ] as Keyframe[],
+      320,
+      'fill',
+      1920,
+      1080,
+      1920,
+      1080,
+      30,
+      false
+    );
+    expect(filter).toContain('[1:v]setpts=PTS-STARTPTS,scale=');
+    expect(filter).not.toContain('hflip');
+  });
+
   test('buildFilterComplex scales screen into the editor canvas', () => {
     const filter = buildFilterComplex(
       [