diff --git a/src/constants.js b/src/constants.js
index e7d9c8c99b646..d9a6283b4cf5a 100644
--- a/src/constants.js
+++ b/src/constants.js
@@ -46,8 +46,15 @@ const IpcChannels = {
   CHOOSE_DEFAULT_FOLDER: 'choose-default-folder',
   WRITE_TO_DEFAULT_FOLDER: 'write-to-default-folder',
 
+  CHOOSE_YTDLP_OUTPUT_DIRECTORY: 'choose-ytdlp-output-directory',
+  CHOOSE_YTDLP_EXECUTABLE: 'choose-ytdlp-executable',
+  FIND_EXECUTABLE_ON_PATH: 'find-executable-on-path',
+  GET_DOWNLOADER_EXECUTABLE_VERSIONS: 'get-downloader-executable-versions',
+
   OPEN_IN_EXTERNAL_PLAYER: 'open-in-external-player',
-  OPEN_IN_EXTERNAL_PLAYER_RESULT: 'open-in-external-player-result'
+  OPEN_IN_EXTERNAL_PLAYER_RESULT: 'open-in-external-player-result',
+
+  DOWNLOAD_VIDEO: 'download-video'
 }
 
 const DBActions = {
diff --git a/src/main/download.js b/src/main/download.js
new file mode 100644
index 0000000000000..c614e5472218e
--- /dev/null
+++ b/src/main/download.js
@@ -0,0 +1,305 @@
+import { app, BrowserWindow, dialog } from 'electron'
+import { execFile, spawn } from 'node:child_process'
+import { access, constants } from 'node:fs/promises'
+import { normalize } from 'node:path'
+import { promisify } from 'node:util'
+import { settings } from '../datastores/handlers/base'
+import { isFreeTubeUrl } from './utils'
+
+const execFileAsync = promisify(execFile)
+
+const ID_REGEX = /^[\w-]+$/
+
+/**
+ * @param {string} path
+ * @returns {Promise<boolean>}
+ */
+async function isExecutable(path) {
+  try {
+    await access(path, constants.X_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * @param {string} name
+ * @returns {Promise<string | null>}
+ */
+export async function findExecutableOnPath(name) {
+  try {
+    const { stdout } = process.platform === 'win32'
+      ? await execFileAsync('where', [name])
+      : await execFileAsync('which', [name])
+
+    return stdout.split(/\r?\n/)[0].trim() || null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * @param {string} name
+ * @param {string} currentPath
+ * @returns {Promise<string | null>}
+ */
+export async function resolveExecutable(name, currentPath) {
+  if (currentPath.length > 0 && await isExecutable(currentPath)) {
+    return currentPath
+  }
+
+  return findExecutableOnPath(name)
+}
+
+/**
+ * @param {string} executable
+ * @param {string[]} versionArgs
+ * @returns {Promise<string | null>}
+ */
+async function getVersion(executable, versionArgs) {
+  if (executable.length === 0 || !await isExecutable(executable)) {
+    return null
+  }
+
+  try {
+    const { stdout } = await execFileAsync(executable, versionArgs)
+    return stdout.split(/\r?\n/)[0].trim() || null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * @param {string} ytdlpExecutable
+ * @returns {Promise<{ ytdlp: string | null }>}
+ */
+export async function getExecutableVersions(ytdlpExecutable) {
+  const ytdlp = await getVersion(ytdlpExecutable, ['--version'])
+
+  return { ytdlp }
+}
+
+/**
+ * Terminal emulators to try on Linux, in order, along with how each one
+ * expects the command to run to be passed.
+ * @type {{ name: string, buildArgs: (shellCommand: string) => string[] }[]}
+ */
+const LINUX_TERMINALS = [
+  { name: 'x-terminal-emulator', buildArgs: (shellCommand) => ['-e', 'sh', '-c', shellCommand] },
+  { name: 'gnome-terminal', buildArgs: (shellCommand) => ['--', 'sh', '-c', shellCommand] },
+  { name: 'konsole', buildArgs: (shellCommand) => ['-e', 'sh', '-c', shellCommand] },
+  { name: 'xfce4-terminal', buildArgs: (shellCommand) => ['-x', 'sh', '-c', shellCommand] },
+  { name: 'kitty', buildArgs: (shellCommand) => ['sh', '-c', shellCommand] },
+  { name: 'alacritty', buildArgs: (shellCommand) => ['-e', 'sh', '-c', shellCommand] },
+  { name: 'xterm', buildArgs: (shellCommand) => ['-e', 'sh', '-c', shellCommand] },
+]
+
+/**
+ * @returns {Promise<{ name: string, buildArgs: (shellCommand: string) => string[] } | null>}
+ */
+async function findLinuxTerminal() {
+  for (const terminal of LINUX_TERMINALS) {
+    if (await findExecutableOnPath(terminal.name)) {
+      return terminal
+    }
+  }
+
+  return null
+}
+
+/**
+ * @param {string} path
+ * @returns {Promise<boolean>}
+ */
+async function hasWriteAccess(path) {
+  try {
+    await access(path, constants.W_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * @param {import('electron').WebContents} webContents
+ * @param {string | undefined} [defaultPath]
+ * @returns {Promise<string | null>}
+ */
+async function promptForOutputDirectory(webContents, defaultPath) {
+  const dialogOptions = {
+    defaultPath: typeof defaultPath === 'string' && defaultPath.length > 0 ? defaultPath : app.getPath('downloads'),
+    properties: ['openDirectory']
+  }
+
+  const window = BrowserWindow.fromWebContents(webContents)
+  const result = window
+    ? await dialog.showOpenDialog(window, dialogOptions)
+    : await dialog.showOpenDialog(dialogOptions)
+
+  if (result.canceled) {
+    return null
+  }
+
+  return result.filePaths[0]
+}
+
+/**
+ * @typedef {'ok' | 'invalid' | 'not-configured' | 'disabled' | 'cancelled' | 'error'} DownloadVideoResult
+ */
+
+/**
+ * @param {import('electron').IpcMainInvokeEvent} event
+ * @param {{ videoId: string, mode: 'video' | 'audio', startTime: number | null | undefined, endTime: number | null | undefined }} payload
+ * @returns {Promise<DownloadVideoResult>}
+ */
+export async function handleDownloadVideo(event, payload) {
+  if (!isFreeTubeUrl(event.senderFrame.url) || !event.sender.isFocused()) {
+    return 'invalid'
+  }
+
+  const { videoId, mode, startTime, endTime } = payload ?? {}
+
+  if (typeof videoId !== 'string' || videoId.length !== 11 || !ID_REGEX.test(videoId)) {
+    return 'invalid'
+  }
+
+  if (mode !== 'video' && mode !== 'audio') {
+    return 'invalid'
+  }
+
+  /** @type {boolean} */
+  const downloadEnabled = (await settings._findOne('ytdlpDownloadEnabled'))?.value || false
+
+  if (!downloadEnabled) {
+    return 'disabled'
+  }
+
+  const hasValidStartTime = typeof startTime === 'number' && startTime >= 0
+  const hasValidEndTime = typeof endTime === 'number' && endTime > 0
+
+  /** @type {string} */
+  const executable = (await settings._findOne('ytdlpExecutable'))?.value || ''
+
+  if (executable.length === 0) {
+    return 'not-configured'
+  }
+
+  /** @type {string} */
+  const downloadMode = (await settings._findOne('ytdlpDownloadMode'))?.value || 'prompt_folder'
+
+  /** @type {string} */
+  const storedOutputDirectory = (await settings._findOne('ytdlpOutputDirectory'))?.value || ''
+
+  const canUseStoredDirectory = downloadMode === 'default_folder' && storedOutputDirectory.length > 0 &&
+    await hasWriteAccess(normalize(storedOutputDirectory))
+
+  // Either "always ask" mode, or the stored folder is unset/no longer writable
+  // (e.g. a Flatpak-portal-granted folder that got revoked) - prompt for one.
+  const outputDirectory = canUseStoredDirectory
+    ? storedOutputDirectory
+    : await promptForOutputDirectory(event.sender, storedOutputDirectory)
+
+  if (!outputDirectory) {
+    return 'cancelled'
+  }
+
+  const customArgsSettingId = mode === 'audio' ? 'ytdlpAudioCustomArgs' : 'ytdlpVideoCustomArgs'
+
+  /** @type {string} */
+  const customArgs = (await settings._findOne(customArgsSettingId))?.value || ''
+
+  const videoUrl = `https://www.youtube.com/watch?v=${videoId}`
+
+  const args = ['-o', `${outputDirectory}/%(title)s.%(ext)s`]
+
+  if (hasValidStartTime || hasValidEndTime) {
+    const start = hasValidStartTime ? startTime : 0
+    const end = hasValidEndTime ? endTime : 'inf'
+    args.push('--download-sections', `*${start}-${end}`)
+  }
+
+  if (mode === 'audio') {
+    args.push('-x')
+  }
+
+  if (customArgs.trim().length > 0) {
+    args.push(...customArgs.trim().split(/\s+/))
+  }
+
+  args.push(videoUrl)
+
+  const fullCommand = [executable, ...args]
+
+  if (process.platform === 'win32') {
+    // echo doesn't parse quotes, so the display line is only quoted where a part has a space
+    const displayCommand = fullCommand.map(part => part.includes(' ') ? `"${part}"` : part).join(' ')
+    // cmd /k only strips quotes if they enclose the whole string, so wrap it twice
+    const runCommand = fullCommand.map(part => `"${part.replaceAll('"', '""')}"`).join(' ')
+    const innerCommand = `echo ${displayCommand} && ${runCommand}`
+
+    return spawnAndAwait('cmd.exe', ['/c', 'start', '""', '/wait', 'cmd.exe', '/k', `"${innerCommand}"`], {
+      windowsVerbatimArguments: true
+    })
+  }
+
+  const shellCommand = `echo ${quoteForShellDisplay(fullCommand)} && exec ${quoteForShell(fullCommand)}`
+
+  if (process.platform === 'darwin') {
+    const appleScript = `tell application "Terminal" to do script ${quoteForAppleScript(shellCommand)}`
+    return spawnAndAwait('osascript', ['-e', appleScript])
+  }
+
+  const terminal = await findLinuxTerminal()
+
+  if (!terminal) {
+    return 'error'
+  }
+
+  return spawnAndAwait(terminal.name, terminal.buildArgs(shellCommand))
+}
+
+/**
+ * @param {string[]} parts
+ * @returns {string}
+ */
+function quoteForShell(parts) {
+  return parts.map(part => `'${part.replaceAll("'", "'\\''")}'`).join(' ')
+}
+
+/**
+ * @param {string[]} parts
+ * @returns {string}
+ */
+function quoteForShellDisplay(parts) {
+  return parts.map(part => part.includes(' ') ? `'${part}'` : part).join(' ')
+}
+
+/**
+ * @param {string} command
+ * @returns {string}
+ */
+function quoteForAppleScript(command) {
+  return `"${command.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`
+}
+
+/**
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import('node:child_process').SpawnOptionsWithoutStdio} [extraOptions]
+ * @returns {Promise<DownloadVideoResult>}
+ */
+function spawnAndAwait(command, args, extraOptions) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { detached: true, stdio: 'ignore', ...extraOptions })
+
+    child.once('error', () => {
+      resolve('error')
+    })
+
+    child.once('spawn', () => {
+      child.unref()
+      resolve('ok')
+    })
+  })
+}
diff --git a/src/main/index.js b/src/main/index.js
index 5ca4678343539..2551932bda187 100644
--- a/src/main/index.js
+++ b/src/main/index.js
@@ -28,6 +28,7 @@ import contextMenu from 'electron-context-menu'
 
 import packageDetails from '../../package.json'
 import { handleOpenInExternalPlayer } from './externalPlayer'
+import { getExecutableVersions, handleDownloadVideo, resolveExecutable } from './download'
 import { generatePoToken } from './poTokenGenerator'
 import { isFreeTubeUrl } from './utils'
 
@@ -1433,6 +1434,93 @@ function runApp() {
     return result.filePaths[0]
   }
 
+  /**
+   * @param {string} settingId
+   * @param {string} value
+   */
+  async function persistAndSyncSetting(settingId, value) {
+    await baseHandlers.settings.upsert(settingId, value)
+
+    const syncPayload = {
+      event: SyncEvents.GENERAL.UPSERT,
+      data: {
+        _id: settingId,
+        value
+      }
+    }
+
+    BrowserWindow.getAllWindows().forEach((window) => {
+      if (isFreeTubeUrl(window.webContents.getURL())) {
+        window.webContents.send(IpcChannels.SYNC_SETTINGS, syncPayload)
+      }
+    })
+  }
+
+  ipcMain.handle(IpcChannels.CHOOSE_YTDLP_OUTPUT_DIRECTORY, async (event) => {
+    if (!isFreeTubeUrl(event.senderFrame.url)) {
+      return null
+    }
+
+    const currentPath = (await baseHandlers.settings._findOne('ytdlpOutputDirectory'))?.value
+
+    const dialogOptions = {
+      defaultPath: typeof currentPath === 'string' && currentPath.length > 0 ? currentPath : app.getPath('downloads'),
+      properties: ['openDirectory']
+    }
+
+    const window = BrowserWindow.fromWebContents(event.sender)
+    const result = window
+      ? await dialog.showOpenDialog(window, dialogOptions)
+      : await dialog.showOpenDialog(dialogOptions)
+
+    if (result.canceled) {
+      return null
+    }
+
+    await persistAndSyncSetting('ytdlpOutputDirectory', result.filePaths[0])
+    return result.filePaths[0]
+  })
+
+  /**
+   * @param {import('electron').IpcMainInvokeEvent} event
+   * @param {string} settingId
+   * @returns {Promise<string | null>}
+   */
+  async function chooseExecutable(event, settingId) {
+    if (!isFreeTubeUrl(event.senderFrame.url)) {
+      return null
+    }
+
+    const currentPath = (await baseHandlers.settings._findOne(settingId))?.value
+
+    const dialogOptions = {
+      defaultPath: typeof currentPath === 'string' && currentPath.length > 0 ? currentPath : undefined,
+      properties: ['openFile'],
+      ...(process.platform === 'win32' && {
+        filters: [
+          { name: 'Executables', extensions: ['exe'] },
+          { name: 'All Files', extensions: ['*'] }
+        ]
+      })
+    }
+
+    const window = BrowserWindow.fromWebContents(event.sender)
+    const result = window
+      ? await dialog.showOpenDialog(window, dialogOptions)
+      : await dialog.showOpenDialog(dialogOptions)
+
+    if (result.canceled) {
+      return null
+    }
+
+    await persistAndSyncSetting(settingId, result.filePaths[0])
+    return result.filePaths[0]
+  }
+
+  ipcMain.handle(IpcChannels.CHOOSE_YTDLP_EXECUTABLE, async (event) => {
+    return chooseExecutable(event, 'ytdlpExecutable')
+  })
+
   ipcMain.on(IpcChannels.CHOOSE_DEFAULT_FOLDER, async (event) => {
     if (!isFreeTubeUrl(event.senderFrame.url)) {
       return
@@ -1572,6 +1660,38 @@ function runApp() {
 
   ipcMain.on(IpcChannels.OPEN_IN_EXTERNAL_PLAYER, handleOpenInExternalPlayer)
 
+  ipcMain.handle(IpcChannels.DOWNLOAD_VIDEO, handleDownloadVideo)
+
+  ipcMain.handle(IpcChannels.FIND_EXECUTABLE_ON_PATH, async (event, name, settingId) => {
+    if (
+      !isFreeTubeUrl(event.senderFrame.url) ||
+      typeof name !== 'string' || !/^[\w-]+$/.test(name) ||
+      settingId !== 'ytdlpExecutable'
+    ) {
+      return null
+    }
+
+    const currentPath = (await baseHandlers.settings._findOne(settingId))?.value || ''
+
+    const resolvedPath = await resolveExecutable(name, currentPath)
+
+    if (resolvedPath && resolvedPath !== currentPath) {
+      await persistAndSyncSetting(settingId, resolvedPath)
+    }
+
+    return resolvedPath
+  })
+
+  ipcMain.handle(IpcChannels.GET_DOWNLOADER_EXECUTABLE_VERSIONS, async (event) => {
+    if (!isFreeTubeUrl(event.senderFrame.url)) {
+      return { ytdlp: null }
+    }
+
+    const ytdlpExecutable = (await baseHandlers.settings._findOne('ytdlpExecutable'))?.value || ''
+
+    return getExecutableVersions(ytdlpExecutable)
+  })
+
   ipcMain.handle(IpcChannels.GET_REPLACE_HTTP_CACHE, (event) => {
     if (isFreeTubeUrl(event.senderFrame.url)) {
       return replaceHttpCache
diff --git a/src/preload/interface.js b/src/preload/interface.js
index b32286c8c07c5..0149f05141083 100644
--- a/src/preload/interface.js
+++ b/src/preload/interface.js
@@ -131,6 +131,36 @@ export default {
     ipcRenderer.send(IpcChannels.CHOOSE_DEFAULT_FOLDER)
   },
 
+  /**
+   * @returns {Promise<string | null>}
+   */
+  chooseYtdlpOutputDirectory: () => {
+    return ipcRenderer.invoke(IpcChannels.CHOOSE_YTDLP_OUTPUT_DIRECTORY)
+  },
+
+  /**
+   * @returns {Promise<string | null>}
+   */
+  chooseYtdlpExecutable: () => {
+    return ipcRenderer.invoke(IpcChannels.CHOOSE_YTDLP_EXECUTABLE)
+  },
+
+  /**
+   * @param {string} name
+   * @param {'ytdlpExecutable'} settingId
+   * @returns {Promise<string | null>}
+   */
+  resolveExecutablePath: (name, settingId) => {
+    return ipcRenderer.invoke(IpcChannels.FIND_EXECUTABLE_ON_PATH, name, settingId)
+  },
+
+  /**
+   * @returns {Promise<{ ytdlp: string | null }>}
+   */
+  getDownloaderExecutableVersions: () => {
+    return ipcRenderer.invoke(IpcChannels.GET_DOWNLOADER_EXECUTABLE_VERSIONS)
+  },
+
   /**
    * @param {string} filename
    * @param {ArrayBuffer} contents
@@ -168,6 +198,22 @@ export default {
       })
   },
 
+  /**
+   * @param {string} videoId
+   * @param {'video' | 'audio'} mode
+   * @param {number | null} [startTime]
+   * @param {number | null} [endTime]
+   * @returns {Promise<import('../main/download').DownloadVideoResult>}
+   */
+  downloadVideo: (videoId, mode, startTime, endTime) => {
+    // require the user to have interacted with the page recently
+    if (navigator.userActivation.isActive) {
+      return ipcRenderer.invoke(IpcChannels.DOWNLOAD_VIDEO, { videoId, mode, startTime, endTime })
+    }
+
+    return Promise.resolve('invalid')
+  },
+
   /**
    * @param {number} factor
    */
diff --git a/src/renderer/components/ExternalDownloaderSettings.vue b/src/renderer/components/ExternalDownloaderSettings.vue
new file mode 100644
index 0000000000000..1734bc03aab82
--- /dev/null
+++ b/src/renderer/components/ExternalDownloaderSettings.vue
@@ -0,0 +1,322 @@
+<template>
+  <FtSettingsSection
+    :title="t('Settings.External Downloader Settings.External Downloader Settings')"
+  >
+    <FtFlexBox class="topRow">
+      <FtToggleSwitch
+        :label="t('Settings.External Downloader Settings.Enable Downloads')"
+        :compact="true"
+        :default-value="downloadEnabled"
+        @change="updateDownloadEnabled"
+      />
+      <FtButton
+        :label="t('Settings.External Downloader Settings.yt-dlp Readme')"
+        :icon="['fas', 'external-link-alt']"
+        @click="openYtdlpReadme"
+      />
+    </FtFlexBox>
+    <template v-if="downloadEnabled">
+      <FtFlexBox class="settingsFlexStart460px pathRow">
+        <div class="inputWithCustomLabel">
+          <p class="customLabel">
+            {{ t('Settings.External Downloader Settings.yt-dlp Executable Path') }}
+            <FtTooltip
+              class="selectTooltip"
+              position="bottom"
+              :tooltip="t('Tooltips.External Downloader Settings.yt-dlp Executable Path')"
+            />
+            <a
+              class="downloadLink"
+              :aria-label="t('Settings.External Downloader Settings.Download yt-dlp')"
+              :title="t('Settings.External Downloader Settings.Download yt-dlp')"
+              href="javascript:void(0)"
+              @click="openYtdlpReleases"
+            >
+              <FontAwesomeIcon :icon="['fas', 'download']" />
+            </a>
+            <span
+              v-if="ytdlpVersion"
+              class="versionText"
+            >{{ ytdlpVersion }}</span>
+          </p>
+          <FtInput
+            :placeholder="t('Settings.External Downloader Settings.yt-dlp Executable Path')"
+            :show-action-button="false"
+            :show-label="false"
+            :value="ytdlpExecutable"
+            @input="updateYtdlpExecutable"
+          />
+        </div>
+        <FtButton
+          class="folderButton"
+          :icon="['fas', 'folder-open']"
+          :title="t('Settings.External Downloader Settings.Choose Executable')"
+          @click="chooseYtdlpExecutable"
+        />
+      </FtFlexBox>
+      <FtFlexBox class="customArgsRow">
+        <div class="modeSelectWrapper">
+          <FtSelect
+            :placeholder="t('Settings.External Downloader Settings.Output Directory Mode')"
+            :value="downloadMode"
+            :select-names="downloadModeNames"
+            :select-values="downloadModeValues"
+            :icon="['fas', 'folder-open']"
+            :tooltip="t('Tooltips.External Downloader Settings.Output Directory Mode')"
+            @change="updateDownloadMode"
+          />
+        </div>
+        <div
+          v-if="downloadMode === 'default_folder'"
+          class="inputWithCustomLabel outputDirectoryField"
+        >
+          <FtInput
+            :placeholder="t('Settings.External Downloader Settings.Output Directory')"
+            :show-action-button="false"
+            :show-label="true"
+            :value="ytdlpOutputDirectory"
+            :tooltip="t('Tooltips.External Downloader Settings.Output Directory')"
+            @input="updateYtdlpOutputDirectory"
+          />
+          <FtButton
+            class="folderButton"
+            :icon="['fas', 'folder-open']"
+            :title="t('Settings.External Downloader Settings.Choose Output Directory')"
+            @click="chooseYtdlpOutputDirectory"
+          />
+        </div>
+      </FtFlexBox>
+      <FtFlexBox class="customArgsRow">
+        <div class="inputWithCustomLabel">
+          <FtInput
+            :placeholder="t('Settings.External Downloader Settings.Video - Custom Arguments')"
+            :show-action-button="false"
+            :show-label="true"
+            :value="ytdlpVideoCustomArgs"
+            :tooltip="t('Tooltips.External Downloader Settings.Video - Custom Arguments')"
+            @input="updateYtdlpVideoCustomArgs"
+          />
+        </div>
+        <div class="inputWithCustomLabel">
+          <FtInput
+            :placeholder="t('Settings.External Downloader Settings.Audio - Custom Arguments')"
+            :show-action-button="false"
+            :show-label="true"
+            :value="ytdlpAudioCustomArgs"
+            :tooltip="t('Tooltips.External Downloader Settings.Audio - Custom Arguments')"
+            @input="updateYtdlpAudioCustomArgs"
+          />
+        </div>
+      </FtFlexBox>
+    </template>
+  </FtSettingsSection>
+</template>
+
+<script setup>
+import { FontAwesomeIcon } from '@fortawesome/vue-fontawesome'
+import { computed, onMounted, ref } from 'vue'
+import { useI18n } from 'vue-i18n'
+
+import FtSettingsSection from './FtSettingsSection/FtSettingsSection.vue'
+import FtInput from './FtInput/FtInput.vue'
+import FtButton from './FtButton/FtButton.vue'
+import FtFlexBox from './ft-flex-box/ft-flex-box.vue'
+import FtSelect from './FtSelect/FtSelect.vue'
+import FtToggleSwitch from './FtToggleSwitch/FtToggleSwitch.vue'
+import FtTooltip from './FtTooltip/FtTooltip.vue'
+
+import store from '../store/index'
+import { debounce, openExternalLink } from '../helpers/utils'
+
+const { t } = useI18n()
+
+/** @type {import('vue').ComputedRef<boolean>} */
+const downloadEnabled = computed(() => store.getters.getYtdlpDownloadEnabled)
+
+/** @type {import('vue').ComputedRef<string>} */
+const ytdlpExecutable = computed(() => store.getters.getYtdlpExecutable)
+
+/** @type {import('vue').ComputedRef<string>} */
+const ytdlpOutputDirectory = computed(() => store.getters.getYtdlpOutputDirectory)
+
+/** @type {import('vue').ComputedRef<string>} */
+const ytdlpVideoCustomArgs = computed(() => store.getters.getYtdlpVideoCustomArgs)
+
+/** @type {import('vue').ComputedRef<string>} */
+const ytdlpAudioCustomArgs = computed(() => store.getters.getYtdlpAudioCustomArgs)
+
+/**
+ * @param {boolean} value
+ */
+function updateDownloadEnabled(value) {
+  store.dispatch('updateYtdlpDownloadEnabled', value)
+}
+
+const downloadModeNames = computed(() => [
+  t('Settings.External Downloader Settings.Output Directory Modes.Ask Path'),
+  t('Settings.External Downloader Settings.Output Directory Modes.Save To Folder'),
+])
+const downloadModeValues = computed(() => ['prompt_folder', 'default_folder'])
+
+/** @type {import('vue').ComputedRef<'prompt_folder' | 'default_folder'>} */
+const downloadMode = computed(() => store.getters.getYtdlpDownloadMode)
+
+/**
+ * @param {'prompt_folder' | 'default_folder'} value
+ */
+function updateDownloadMode(value) {
+  store.dispatch('updateYtdlpDownloadMode', value)
+}
+
+/**
+ * @param {string} value
+ */
+async function updateYtdlpExecutable(value) {
+  store.dispatch('updateYtdlpExecutable', value)
+  await debouncedRefreshVersion()
+}
+
+async function chooseYtdlpExecutable() {
+  if (process.env.IS_ELECTRON) {
+    const chosenPath = await window.ftElectron.chooseYtdlpExecutable()
+    if (chosenPath) {
+      store.dispatch('updateYtdlpExecutable', chosenPath)
+    }
+    await refreshVersion()
+  }
+}
+
+async function chooseYtdlpOutputDirectory() {
+  if (process.env.IS_ELECTRON) {
+    const chosenPath = await window.ftElectron.chooseYtdlpOutputDirectory()
+    if (chosenPath) {
+      store.dispatch('updateYtdlpOutputDirectory', chosenPath)
+    }
+  }
+}
+
+/**
+ * @param {string} value
+ */
+function updateYtdlpOutputDirectory(value) {
+  store.dispatch('updateYtdlpOutputDirectory', value)
+}
+
+/**
+ * @param {string} value
+ */
+function updateYtdlpVideoCustomArgs(value) {
+  store.dispatch('updateYtdlpVideoCustomArgs', value)
+}
+
+/**
+ * @param {string} value
+ */
+function updateYtdlpAudioCustomArgs(value) {
+  store.dispatch('updateYtdlpAudioCustomArgs', value)
+}
+
+function openYtdlpReadme() {
+  openExternalLink('https://github.com/yt-dlp/yt-dlp#readme')
+}
+
+function openYtdlpReleases() {
+  openExternalLink('https://github.com/yt-dlp/yt-dlp/releases')
+}
+
+const ytdlpVersion = ref('')
+
+async function refreshVersion() {
+  if (!process.env.IS_ELECTRON) {
+    return
+  }
+
+  const { ytdlp } = await window.ftElectron.getDownloaderExecutableVersions()
+  ytdlpVersion.value = ytdlp || ''
+}
+
+const debouncedRefreshVersion = debounce(refreshVersion, 500)
+
+onMounted(async () => {
+  if (!process.env.IS_ELECTRON) {
+    return
+  }
+
+  const resolvedYtdlp = await window.ftElectron.resolveExecutablePath('yt-dlp', 'ytdlpExecutable')
+  if (resolvedYtdlp && resolvedYtdlp !== ytdlpExecutable.value) {
+    store.dispatch('updateYtdlpExecutable', resolvedYtdlp)
+  }
+
+  await refreshVersion()
+})
+</script>
+
+<style scoped>
+:deep(.ft-input-component:focus-within),
+:deep(.ft-input-component:hover) {
+  z-index: 1;
+}
+
+.topRow {
+  justify-content: space-between;
+}
+
+.customArgsRow {
+  align-items: flex-start;
+  gap: 20px;
+}
+
+.pathRow {
+  align-items: flex-end;
+}
+
+.inputWithCustomLabel {
+  flex: 1;
+  min-inline-size: 0;
+}
+
+.customLabel {
+  margin-block: 0 5px;
+  margin-inline: 0;
+  display: flex;
+  align-items: center;
+}
+
+.folderButton {
+  min-inline-size: 0;
+  padding: 12px;
+  margin-block-end: 10px;
+}
+
+.modeSelectWrapper {
+  padding-block-start: 24px;
+}
+
+.modeSelectWrapper :deep(.select) {
+  margin-block-start: 0;
+}
+
+.outputDirectoryField {
+  display: flex;
+  flex: 1;
+  align-items: flex-end;
+  gap: 10px;
+  padding-block-start: 5px;
+}
+
+.outputDirectoryField :deep(.ft-input-component) {
+  flex: 1;
+  min-inline-size: 0;
+}
+
+.downloadLink {
+  color: var(--primary-text-color);
+  margin-inline-start: 8px;
+}
+
+.versionText {
+  color: var(--tertiary-text-color);
+  margin-inline-start: 8px;
+  font-size: 0.85em;
+}
+</style>
diff --git a/src/renderer/components/WatchVideoInfo/WatchVideoInfo.css b/src/renderer/components/WatchVideoInfo/WatchVideoInfo.css
index 61b26e46c2ef7..03018e9844cb5 100644
--- a/src/renderer/components/WatchVideoInfo/WatchVideoInfo.css
+++ b/src/renderer/components/WatchVideoInfo/WatchVideoInfo.css
@@ -139,3 +139,31 @@
     inset-inline: 0 auto;
   }
 }
+
+.downloadOptions {
+  padding: 12px;
+  padding-block-end: 0;
+  max-inline-size: min-content;
+  min-inline-size: 150px;
+  margin-inline: auto;
+}
+
+.downloadOptions :deep(.ft-input) {
+  background-color: var(--bg-color);
+  border: 1px solid var(--tertiary-text-color);
+}
+
+.downloadButtons {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding: 12px;
+  max-inline-size: min-content;
+  min-inline-size: 150px;
+  margin-inline: auto;
+}
+
+.downloadButtons .action {
+  padding: 6px;
+  white-space: initial;
+}
diff --git a/src/renderer/components/WatchVideoInfo/WatchVideoInfo.vue b/src/renderer/components/WatchVideoInfo/WatchVideoInfo.vue
index 3a2b430bc2f13..f33d5d171e119 100644
--- a/src/renderer/components/WatchVideoInfo/WatchVideoInfo.vue
+++ b/src/renderer/components/WatchVideoInfo/WatchVideoInfo.vue
@@ -111,6 +111,56 @@
             theme="secondary"
             @click="handleExternalPlayer"
           />
+          <FtIconButton
+            v-if="USING_ELECTRON && downloadEnabled"
+            :title="t('Video.Download Video')"
+            :icon="['fas', 'download']"
+            theme="secondary"
+            :force-dropdown="true"
+          >
+            <div class="downloadOptions">
+              <FtFlexBox>
+                <FtToggleSwitch
+                  :label="t('Video.Download.Timespan')"
+                  :compact="true"
+                  :default-value="downloadIncludeTimestamp"
+                  @change="updateDownloadIncludeTimestamp"
+                />
+              </FtFlexBox>
+              <FtFlexBox v-if="downloadIncludeTimestamp">
+                <FtInput
+                  :placeholder="t('Video.Download.Start Time')"
+                  :show-action-button="false"
+                  :show-label="true"
+                  :value="downloadStartTime"
+                  @input="updateDownloadStartTime"
+                />
+              </FtFlexBox>
+              <FtFlexBox v-if="downloadIncludeTimestamp">
+                <FtInput
+                  :placeholder="t('Video.Download.End Time')"
+                  :show-action-button="false"
+                  :show-label="true"
+                  :value="downloadEndTime"
+                  @input="updateDownloadEndTime"
+                />
+              </FtFlexBox>
+            </div>
+            <div class="downloadButtons">
+              <FtButton
+                class="action"
+                :icon="['fas', 'video']"
+                :label="t('Video.Download.Video')"
+                @click="handleDownload('video')"
+              />
+              <FtButton
+                class="action"
+                :icon="['fas', 'headphones']"
+                :label="t('Video.Download.Audio')"
+                @click="handleDownload('audio')"
+              />
+            </div>
+          </FtIconButton>
           <FtIconButton
             v-if="!isUpcoming"
             :title="t('Change Format.Change Media Formats')"
@@ -133,17 +183,22 @@
 
 <script setup>
 import { FontAwesomeIcon } from '@fortawesome/vue-fontawesome'
-import { computed, onMounted } from 'vue'
+import { computed, onMounted, ref } from 'vue'
 import { useI18n } from 'vue-i18n'
+import { useRouter } from 'vue-router'
 
+import FtButton from '../FtButton/FtButton.vue'
 import FtCard from '../ft-card/ft-card.vue'
+import FtFlexBox from '../ft-flex-box/ft-flex-box.vue'
 import FtIconButton from '../FtIconButton/FtIconButton.vue'
+import FtInput from '../FtInput/FtInput.vue'
 import FtShareButton from '../FtShareButton/FtShareButton.vue'
 import FtSubscribeButton from '../FtSubscribeButton/FtSubscribeButton.vue'
+import FtToggleSwitch from '../FtToggleSwitch/FtToggleSwitch.vue'
 
 import store from '../../store'
 
-import { formatNumber, showToast } from '../../helpers/utils'
+import { formatDurationAsTimestamp, formatNumber, showToast } from '../../helpers/utils'
 
 const props = defineProps({
   id: {
@@ -246,6 +301,7 @@ const emit = defineEmits([
 const USING_ELECTRON = process.env.IS_ELECTRON
 
 const { locale, t } = useI18n()
+const router = useRouter()
 
 /** @type {import('vue').ComputedRef<boolean>} */
 const hideSharingActions = computed(() => store.getters.getHideSharingActions)
@@ -333,6 +389,9 @@ const historyEntryExists = computed(() => store.getters.getHistoryCacheById[prop
 /** @type {import('vue').ComputedRef<string>} */
 const externalPlayer = computed(() => store.getters.getExternalPlayer)
 
+/** @type {import('vue').ComputedRef<boolean>} */
+const downloadEnabled = computed(() => store.getters.getYtdlpDownloadEnabled)
+
 /** @type {import('vue').ComputedRef<number>} */
 const defaultPlayback = computed(() => store.getters.getDefaultPlayback)
 
@@ -392,6 +451,86 @@ function handleExternalPlayer() {
   }
 }
 
+const downloadIncludeTimestamp = ref(false)
+const downloadStartTime = ref('0:00')
+const downloadEndTime = ref('')
+
+function updateDownloadIncludeTimestamp() {
+  downloadIncludeTimestamp.value = !downloadIncludeTimestamp.value
+
+  if (downloadIncludeTimestamp.value) {
+    downloadStartTime.value = formatDurationAsTimestamp(Math.trunc(props.getTimestamp()))
+    downloadEndTime.value = formatDurationAsTimestamp(Math.trunc(props.lengthSeconds))
+  }
+}
+
+/**
+ * @param {string} value
+ */
+function updateDownloadStartTime(value) {
+  downloadStartTime.value = value
+}
+
+/**
+ * @param {string} value
+ */
+function updateDownloadEndTime(value) {
+  downloadEndTime.value = value
+}
+
+/**
+ * @param {string} value
+ * @returns {number | null}
+ */
+function parseTimestampToSeconds(value) {
+  const trimmed = value.trim()
+  if (trimmed === '') {
+    return null
+  }
+
+  const parts = trimmed.split(':')
+  if (parts.length < 2 || parts.length > 3 || parts.some(part => !/^\d+$/.test(part))) {
+    return null
+  }
+
+  const numbers = parts.map(Number)
+  const [hours, minutes, seconds] = numbers.length === 3 ? numbers : [0, ...numbers]
+
+  return (hours * 3600) + (minutes * 60) + seconds
+}
+
+/**
+ * @param {'video' | 'audio'} mode
+ */
+async function handleDownload(mode) {
+  if (!process.env.IS_ELECTRON) {
+    return
+  }
+
+  const startTime = downloadIncludeTimestamp.value ? parseTimestampToSeconds(downloadStartTime.value) : null
+  const endTime = downloadIncludeTimestamp.value ? parseTimestampToSeconds(downloadEndTime.value) : null
+
+  const result = await window.ftElectron.downloadVideo(props.id, mode, startTime, endTime)
+
+  switch (result) {
+    case 'ok':
+      showToast(mode === 'audio'
+        ? t('Video.Audio download has started')
+        : t('Video.Video download has started'))
+      break
+    case 'cancelled':
+      // user closed the folder picker, nothing to report
+      break
+    case 'disabled':
+    case 'not-configured':
+    case 'error':
+      showToast(t('Video.Download failed - Click to open External Downloader settings'), 10000, () => {
+        router.push({ path: '/settings', query: { section: 'external-downloader' } })
+      })
+      break
+  }
+}
+
 onMounted(() => {
   if (process.env.IS_ELECTRON || 'mediaSession' in navigator) {
     navigator.mediaSession.metadata = new MediaMetadata({
diff --git a/src/renderer/main.js b/src/renderer/main.js
index 763d6a0875973..b16d3538c5617 100644
--- a/src/renderer/main.js
+++ b/src/renderer/main.js
@@ -61,12 +61,14 @@ import {
   faFilterCircleXmark,
   faFlask,
   faFire,
+  faFolderOpen,
   faForward,
   faGamepad,
   faGauge,
   faGlobe,
   faGrip,
   faHashtag,
+  faHeadphones,
   faHeart,
   faHistory,
   faImages,
@@ -186,12 +188,14 @@ library.add(
   faFilterCircleXmark,
   faFlask,
   faFire,
+  faFolderOpen,
   faForward,
   faGamepad,
   faGauge,
   faGlobe,
   faGrip,
   faHashtag,
+  faHeadphones,
   faHeart,
   faHistory,
   faImages,
diff --git a/src/renderer/store/modules/settings.js b/src/renderer/store/modules/settings.js
index 694be8ff0be32..540f5b47497ea 100644
--- a/src/renderer/store/modules/settings.js
+++ b/src/renderer/store/modules/settings.js
@@ -189,6 +189,12 @@ const state = {
   externalPlayerIgnoreDefaultArgs: false,
   externalPlayerCustomArgs: '[]',
   showAddedExternalPlayerCustomArgs: true,
+  ytdlpDownloadEnabled: false,
+  ytdlpDownloadMode: 'prompt_folder',
+  ytdlpExecutable: '',
+  ytdlpOutputDirectory: '',
+  ytdlpVideoCustomArgs: '',
+  ytdlpAudioCustomArgs: '',
   expandSideBar: false,
   hideActiveSubscriptions: false,
   hideChannelCommunity: false,
@@ -440,6 +446,11 @@ export const NON_TRANSFERABLE_SETTINGS = new Set([
   'externalPlayerIgnoreDefaultArgs',
   'externalPlayerCustomArgs',
   'showAddedExternalPlayerCustomArgs',
+  // ExternalDownloaderSettings
+  'ytdlpExecutable',
+  'ytdlpOutputDirectory',
+  'ytdlpVideoCustomArgs',
+  'ytdlpAudioCustomArgs',
   // Others
   'disableSmoothScrolling',
   'hideToTrayOnMinimize',
diff --git a/src/renderer/views/Settings/Settings.vue b/src/renderer/views/Settings/Settings.vue
index 927361de33235..f2a3331bd3982 100644
--- a/src/renderer/views/Settings/Settings.vue
+++ b/src/renderer/views/Settings/Settings.vue
@@ -61,13 +61,15 @@
 
 <script setup>
 import { FontAwesomeIcon } from '@fortawesome/vue-fontawesome'
-import { computed, nextTick, onBeforeUnmount, onMounted, ref, useTemplateRef } from 'vue'
+import { computed, nextTick, onBeforeUnmount, onMounted, ref, useTemplateRef, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
+import { useRoute } from 'vue-router'
 
 import GeneralSettings from '../../components/GeneralSettings/GeneralSettings.vue'
 import ThemeSettings from '../../components/ThemeSettings.vue'
 import PlayerSettings from '../../components/PlayerSettings/PlayerSettings.vue'
 import ExternalPlayerSettings from '../../components/ExternalPlayerSettings.vue'
+import ExternalDownloaderSettings from '../../components/ExternalDownloaderSettings.vue'
 import SubscriptionSettings from '../../components/SubscriptionSettings/SubscriptionSettings.vue'
 import PrivacySettings from '../../components/PrivacySettings.vue'
 import DataSettings from '../../components/DataSettings/DataSettings.vue'
@@ -88,6 +90,7 @@ const USING_ELECTRON = !!process.env.IS_ELECTRON
 const SETTINGS_MOBILE_WIDTH_THRESHOLD = 1015
 
 const { locale, t } = useI18n()
+const route = useRoute()
 
 const isInDesktopView = ref(true)
 const settingsSectionTypeOpenInMobile = ref(null)
@@ -118,6 +121,14 @@ const settingsComponentsData = computed(() => {
           component: ExternalPlayerSettings
         }]
       : []),
+    ...(process.env.IS_ELECTRON
+      ? [{
+          type: 'external-downloader',
+          title: t('Settings.External Downloader Settings.External Downloader Settings'),
+          icon: ['fas', 'download'],
+          component: ExternalDownloaderSettings
+        }]
+      : []),
     {
       type: 'subscription',
       title: t('Settings.Subscription Settings.Subscription Settings'),
@@ -214,6 +225,8 @@ if (unlocked.value) {
   onMounted(handleMounted)
 }
 
+watch(() => route.query.section, navigateToRequestedSection)
+
 function handleUnlock() {
   unlocked.value = true
 
@@ -245,6 +258,23 @@ function handleMounted() {
 
   // mark first section as active before any scrolling has taken place
   activeSection.value = settingsSectionComponents.value[0].type
+
+  navigateToRequestedSection(route.query.section)
+}
+
+/**
+ * @param {unknown} requestedSection
+ */
+function navigateToRequestedSection(requestedSection) {
+  if (
+    typeof requestedSection === 'string' &&
+    settingsSectionComponents.value.some(section => section.type === requestedSection)
+  ) {
+    // after router's scrollBehavior reset (~500ms)
+    setTimeout(() => {
+      navigateToSection(requestedSection)
+    }, 600)
+  }
 }
 
 const sectionRefs = useTemplateRef('sectionRefs')
diff --git a/static/locales/en-US.yaml b/static/locales/en-US.yaml
index 6dafdfcf6bbb3..c9c3f68f7ba6d 100644
--- a/static/locales/en-US.yaml
+++ b/static/locales/en-US.yaml
@@ -507,6 +507,21 @@ Settings:
     Players:
       None:
         Name: None
+  External Downloader Settings:
+    External Downloader Settings: External Downloader
+    Enable Downloads: Enable Downloads
+    yt-dlp Readme: yt-dlp Readme
+    yt-dlp Executable Path: yt-dlp Executable Path
+    Download yt-dlp: Download yt-dlp
+    Choose Executable: Choose Executable
+    Output Directory Mode: Output Directory Mode
+    Output Directory Modes:
+      Ask Path: Ask Path
+      Save To Folder: Save To Folder
+    Output Directory: Output Directory
+    Choose Output Directory: Choose Output Directory
+    Video - Custom Arguments: Video - Custom Arguments
+    Audio - Custom Arguments: Audio - Custom Arguments
   Privacy Settings:
     Privacy Settings: Privacy
     Remember History: Remember Watch History
@@ -858,6 +873,17 @@ Video:
   Save Video: Save Video
   Video has been saved: Video has been saved
   Video has been removed from your saved list: Video has been removed from your saved list
+  Download Video: Download Video
+  Download:
+    Video: Video
+    Audio: Audio
+    Timespan: Timespan
+    Start Time: Start Time
+    End Time: End Time
+  Video download has started: Video download has started
+  Audio download has started: Audio download has started
+  Download failed - Click to open External Downloader settings: Download failed - Click
+    to open External Downloader settings
   Open in YouTube: Open in YouTube
   Copy YouTube Link: Copy YouTube Link
   Open YouTube Embedded Player: Open YouTube Embedded Player
@@ -1092,6 +1118,18 @@ Tooltips:
       Custom arguments will still be passed on.
     Custom External Player Arguments: Any custom command line arguments you want to be passed on to the external player.
     DefaultCustomArgumentsTemplate: "(Default: '{defaultCustomArguments}')"
+  External Downloader Settings:
+    yt-dlp Executable Path: By default, FreeTube will assume that yt-dlp can be found
+      via the PATH environment variable. If needed, a custom path to the yt-dlp executable
+      can be set here.
+    Output Directory Mode: Ask Path will prompt you to choose a folder every time you download.
+      Save To Folder lets you set one folder to always download to.
+    Output Directory: The directory yt-dlp should save downloaded videos to, passed via
+      yt-dlp's -o/--output option.
+    Video - Custom Arguments: Any custom command line arguments you want to be passed on to yt-dlp
+      when downloading a video.
+    Audio - Custom Arguments: Any custom command line arguments you want to be passed on to yt-dlp
+      when downloading audio only. The -x/--extract-audio flag is always added automatically.
   Distraction Free Settings:
     Hide Channels: Enter a channel ID to hide all videos, playlists and the channel itself from appearing in search, trending, most popular and recommended.
        The channel ID entered must be a complete match and is case sensitive.