diff --git a/README.md b/README.md
index 51f64c5..6b877f3 100644
--- a/README.md
+++ b/README.md
@@ -53,7 +53,12 @@ Environment variables win if both are set.
 
 `DOWNLOAD_DIRS` powers the in-app folder picker. List each drive or folder you want to save
 into, for example `Movies=/mnt/movies,Backup=/mnt/backup`. In Docker, mount each of those
-paths as a volume.
+paths as a volume. The same folders scope which local files can be uploaded, since uploads read
+from the server's local disk into the remote folder you are browsing.
+
+SFTP uploads run single-stream per file (rclone can't multi-thread a single-file SFTP upload).
+Overall upload throughput across multiple files comes from the Concurrent setting in the
+transfer queue.
 
 ## First-run setup
 
@@ -74,11 +79,11 @@ If `APP_PASSWORD` / `APP_PASSWORD_HASH` or `appPassword` / `appPasswordHash` is
 - Connect over SFTP with a password or private key.
 - Browse remote folders with sorting, multi-select, and right-click download.
 - Fast parallel downloads (1 to 16 streams) with live progress and speed.
+- Upload files and folders that already exist on the Siphon server's local disk into the
+  remote folder you are browsing.
 - Downloads keep running on the server even if you close the tab or your phone.
 - Save connections so you don't retype credentials, and pick a save folder per download.
 
-Uploads and remote file management are out of scope for now.
-
 ## Keep it running on boot
 
 - **Docker:** already handled (`restart: unless-stopped` in `docker-compose.yml`).
diff --git a/src/server/app.ts b/src/server/app.ts
index 59ab45d..07808b0 100644
--- a/src/server/app.ts
+++ b/src/server/app.ts
@@ -6,6 +6,7 @@ import { registerSystemRoutes } from './routes/system'
 import { registerConnectionRoutes } from './routes/connection'
 import { registerBrowseRoutes } from './routes/browse'
 import { registerDownloadRoutes } from './routes/downloads'
+import { registerUploadRoutes } from './routes/uploads'
 import { registerProfileRoutes } from './routes/profiles'
 import { registerStatic } from './routes/static'
 
@@ -17,6 +18,7 @@ export async function registerRoutes(app: FastifyInstance, ctx: RouteContext): P
   registerConnectionRoutes(app, ctx)
   registerBrowseRoutes(app, ctx)
   registerDownloadRoutes(app, ctx)
+  registerUploadRoutes(app, ctx)
   registerProfileRoutes(app, ctx)
   await registerStatic(app, ctx)
 }
diff --git a/src/server/localFs.ts b/src/server/localFs.ts
index d4675c0..7adaddf 100644
--- a/src/server/localFs.ts
+++ b/src/server/localFs.ts
@@ -1,4 +1,4 @@
-import { mkdir, readdir, realpath } from 'node:fs/promises'
+import { mkdir, readdir, realpath, lstat } from 'node:fs/promises'
 import { existsSync, type Dirent } from 'node:fs'
 import { isAbsolute, join, relative, resolve } from 'node:path'
 import type { DownloadRoot } from './config'
@@ -133,6 +133,32 @@ export async function makeDir(scope: FsScope, parentPath: string, name: string):
   return canonicalTarget
 }
 
+// Caller must pass an already-resolved, confined directory; this walker only skips symlinks
+// and does not itself enforce scope.
+export async function listFilesRecursive(
+  dir: string
+): Promise<{ relPath: string; size: number }[]> {
+  const results: { relPath: string; size: number }[] = []
+
+  async function walk(current: string, relPrefix: string): Promise<void> {
+    const dirents = await readdir(current, { withFileTypes: true })
+    for (const entry of dirents) {
+      const relPath = relPrefix ? `${relPrefix}/${entry.name}` : entry.name
+      const entryPath = join(current, entry.name)
+      const st = await lstat(entryPath)
+      if (st.isSymbolicLink()) continue
+      if (st.isDirectory()) {
+        await walk(entryPath, relPath)
+      } else if (st.isFile()) {
+        results.push({ relPath, size: st.size })
+      }
+    }
+  }
+
+  await walk(dir, '')
+  return results
+}
+
 async function isConfiguredRoot(roots: DownloadRoot[], canonical: string): Promise<boolean> {
   for (const root of roots) {
     if ((await canonicalize(root.path)) === canonical) return true
diff --git a/src/server/rclone/downloadManager.ts b/src/server/rclone/downloadManager.ts
index 1385792..4d3125e 100644
--- a/src/server/rclone/downloadManager.ts
+++ b/src/server/rclone/downloadManager.ts
@@ -15,6 +15,8 @@ export interface RcloneEnqueueInput {
   size: number
   segments: number
   cleanupRemote?: string
+  direction?: 'download' | 'upload'
+  uploadRemoteDir?: string
 }
 
 interface InternalTransfer {
@@ -93,7 +95,9 @@ export class RcloneDownloadManager extends EventEmitter {
       speedBytesPerSec: 0,
       activeSegments: 0,
       segments: input.segments,
-      status: 'queued'
+      status: 'queued',
+      direction: input.direction ?? 'download',
+      uploadRemoteDir: input.uploadRemoteDir
     }
     this.transfers.set(id, {
       progress,
@@ -301,7 +305,8 @@ export class RcloneDownloadManager extends EventEmitter {
           t.progress.status = 'canceled'
         } else {
           t.progress.status = 'error'
-          t.progress.error = job.error || 'Download failed.'
+          t.progress.error =
+            job.error || (t.progress.direction === 'upload' ? 'Upload failed.' : 'Download failed.')
         }
         t.progress.activeSegments = 0
         t.progress.speedBytesPerSec = 0
diff --git a/src/server/routes/uploads.ts b/src/server/routes/uploads.ts
new file mode 100644
index 0000000..793c945
--- /dev/null
+++ b/src/server/routes/uploads.ts
@@ -0,0 +1,134 @@
+import { basename, isAbsolute, join, posix, relative } from 'node:path'
+import { stat as fsStat } from 'node:fs/promises'
+import { randomUUID } from 'node:crypto'
+import type { FastifyInstance } from 'fastify'
+import type { UploadEnqueueInput } from '../../shared/api'
+import type { TransferProgress } from '../../shared/types'
+import type { RouteContext } from '../context'
+import { httpError } from '../http'
+import { listFilesRecursive, resolvePath, type FsScope } from '../localFs'
+import { safeBaseName, uiToRemotePath } from '../mapping'
+import type { RcloneClient } from '../rclone/client'
+import type { RcloneDownloadManager } from '../rclone/downloadManager'
+
+export interface ExpandUploadInput {
+  resolved: string
+  isDir: boolean
+  size: number
+  remoteDir: string
+  jobRemote: string
+}
+
+export async function expandUpload(
+  client: RcloneClient,
+  manager: RcloneDownloadManager,
+  input: ExpandUploadInput
+): Promise<TransferProgress[]> {
+  const { resolved, isDir, size, remoteDir, jobRemote } = input
+  // SFTP uploads are single-stream (see README); segments is always 1.
+  const segments = 1
+
+  if (isDir) {
+    const dirBaseName = safeBaseName(basename(resolved))
+    let files
+    try {
+      files = await listFilesRecursive(resolved)
+    } catch (err) {
+      await client.deleteRemote(jobRemote).catch(() => undefined)
+      throw err
+    }
+
+    if (files.length === 0) {
+      await client.deleteRemote(jobRemote).catch(() => undefined)
+      return []
+    }
+
+    return files.map((file) => {
+      const displayName = `${dirBaseName}/${file.relPath}`
+      return manager.enqueue({
+        srcFs: resolved,
+        srcRemote: file.relPath,
+        dstFs: `${jobRemote}:`,
+        dstRemote: posix.join(remoteDir, dirBaseName, file.relPath),
+        displayName,
+        localPath: join(resolved, file.relPath),
+        size: file.size,
+        segments,
+        direction: 'upload',
+        uploadRemoteDir: remoteDir,
+        cleanupRemote: jobRemote
+      })
+    })
+  }
+
+  const remoteBaseName = safeBaseName(basename(resolved))
+  const parentDir = join(resolved, '..')
+  const localBaseName = basename(resolved)
+
+  return [
+    manager.enqueue({
+      srcFs: parentDir,
+      srcRemote: localBaseName,
+      dstFs: `${jobRemote}:`,
+      dstRemote: posix.join(remoteDir, remoteBaseName),
+      displayName: remoteBaseName,
+      localPath: resolved,
+      size,
+      segments,
+      direction: 'upload',
+      uploadRemoteDir: remoteDir,
+      cleanupRemote: jobRemote
+    })
+  ]
+}
+
+export function registerUploadRoutes(
+  app: FastifyInstance,
+  { config, services, session }: RouteContext
+): void {
+  const { client, manager } = services
+  const scope: FsScope = { roots: config.roots, confined: config.confined }
+
+  app.post('/api/upload', async (req) => {
+    const input = req.body as UploadEnqueueInput
+    session.remoteFs()
+
+    const resolved = await resolvePath(scope, input.localPath)
+    if (!resolved) throw httpError(400, 'That file or folder is not accessible.')
+
+    const canonicalDataDir = await resolvePath(
+      { roots: [{ name: 'data', path: config.dataDir }], confined: false },
+      config.dataDir
+    )
+    if (canonicalDataDir && isInsideDataDir(canonicalDataDir, resolved)) {
+      throw httpError(400, 'That file or folder is not accessible.')
+    }
+
+    let stats
+    try {
+      stats = await fsStat(resolved)
+    } catch {
+      throw httpError(404, 'File not found.')
+    }
+
+    const remoteDir = uiToRemotePath(input.remoteDir)
+    if (remoteDir.split('/').some((seg) => seg === '..')) {
+      throw httpError(400, 'That destination folder is not allowed.')
+    }
+    const jobRemote = `_ul-${randomUUID()}`
+    await client.cloneRemote(session.remoteName(), jobRemote)
+
+    return expandUpload(client, manager, {
+      resolved,
+      isDir: stats.isDirectory(),
+      size: stats.isDirectory() ? 0 : stats.size,
+      remoteDir,
+      jobRemote
+    })
+  })
+}
+
+function isInsideDataDir(dataDir: string, target: string): boolean {
+  const rel = relative(dataDir, target)
+  return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel))
+}
diff --git a/src/server/services.ts b/src/server/services.ts
index 17f22fc..39f6e45 100644
--- a/src/server/services.ts
+++ b/src/server/services.ts
@@ -28,7 +28,7 @@ export async function createServices(
 async function removeEphemeralRemotes(client: RcloneClient): Promise<void> {
   const names = await client.listRemotes().catch(() => [] as string[])
   for (const name of names) {
-    if (name === '_session' || name.startsWith('_dl-')) {
+    if (name === '_session' || name.startsWith('_dl-') || name.startsWith('_ul-')) {
       await client.deleteRemote(name).catch(() => undefined)
     }
   }
diff --git a/src/shared/api.ts b/src/shared/api.ts
index b8e7aff..6ffe89b 100644
--- a/src/shared/api.ts
+++ b/src/shared/api.ts
@@ -22,6 +22,11 @@ export interface DownloadEnqueueInput {
   segments: number
 }
 
+export interface UploadEnqueueInput {
+  localPath: string
+  remoteDir: string
+}
+
 export interface ConnectionProfileMeta {
   id: string
   name: string
@@ -83,6 +88,7 @@ export interface SftpApi {
   list(dir: string): Promise<RemoteEntry[]>
   stat(path: string): Promise<RemoteStat>
   enqueueDownload(input: DownloadEnqueueInput): Promise<TransferProgress[]>
+  enqueueUpload(input: UploadEnqueueInput): Promise<TransferProgress[]>
   cancelDownload(id: string): Promise<void>
   cancelAllDownloads(): Promise<void>
   clearFinishedDownloads(): Promise<void>
diff --git a/src/shared/types.ts b/src/shared/types.ts
index 7cb8c2e..96bc647 100644
--- a/src/shared/types.ts
+++ b/src/shared/types.ts
@@ -40,6 +40,8 @@ export interface TransferProgress {
   status: TransferStatus
   canceling?: boolean
   error?: string
+  direction?: 'download' | 'upload'
+  uploadRemoteDir?: string
 }
 
 export type DownloadEvent =
diff --git a/src/ui/App.tsx b/src/ui/App.tsx
index c6a3538..c62970e 100644
--- a/src/ui/App.tsx
+++ b/src/ui/App.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
 import { Button, Dialog, FormControl, SegmentedControl, TextInput } from '@primer/react'
 import type { RemoteEntry, TransferProgress } from '@shared/types'
 import type { ConnectionProfileMeta, SaveProfileInput } from '@shared/api'
@@ -77,6 +77,7 @@ export default function App({ canChangePassword }: AppProps) {
   const [selectedProfileId, setSelectedProfileId] = useState('')
   const [rememberSecret, setRememberSecret] = useState(true)
   const [pickerOpen, setPickerOpen] = useState(false)
+  const [pickerMode, setPickerMode] = useState<'chooseDir' | 'chooseItems'>('chooseDir')
   const [mobileTab, setMobileTab] = useState<'files' | 'transfers'>('files')
   const [passwordDialogOpen, setPasswordDialogOpen] = useState(false)
   const [currentPassword, setCurrentPassword] = useState('')
@@ -86,6 +87,20 @@ export default function App({ canChangePassword }: AppProps) {
   const [passwordError, setPasswordError] = useState<string | null>(null)
   const [passwordNotice, setPasswordNotice] = useState<string | null>(null)
 
+  const cwdRef = useRef(cwd)
+  const refreshTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const navigateToRef = useRef<(dir: string) => Promise<boolean>>(async () => false)
+
+  useEffect(() => {
+    cwdRef.current = cwd
+  }, [cwd])
+
+  useEffect(() => {
+    return () => {
+      if (refreshTimerRef.current) clearTimeout(refreshTimerRef.current)
+    }
+  }, [])
+
   useEffect(() => {
     window.api
       .defaultDownloadDir()
@@ -111,6 +126,19 @@ export default function App({ canChangePassword }: AppProps) {
         next[index] = update
         return next
       })
+
+      if (update.direction === 'upload' && update.status === 'completed') {
+        const uploadDir = update.uploadRemoteDir
+        // Server-normalized uploadRemoteDir (uiToRemotePath) strips leading slashes; match that here.
+        const cwdNorm = cwdRef.current.replace(/^\/+/, '')
+        if (uploadDir !== undefined && uploadDir === cwdNorm) {
+          if (refreshTimerRef.current) clearTimeout(refreshTimerRef.current)
+          refreshTimerRef.current = setTimeout(() => {
+            refreshTimerRef.current = null
+            if (cwdRef.current.replace(/^\/+/, '') === uploadDir) navigateToRef.current(cwdRef.current)
+          }, 600)
+        }
+      }
     })
   }, [])
 
@@ -136,6 +164,10 @@ export default function App({ canChangePassword }: AppProps) {
     }
   }, [])
 
+  useEffect(() => {
+    navigateToRef.current = navigateTo
+  }, [navigateTo])
+
   useEffect(() => {
     window.api
       .status()
@@ -295,6 +327,27 @@ export default function App({ canChangePassword }: AppProps) {
     setSelected(new Set())
   }, [entries, selected, enqueue])
 
+  const handleUploadSelected = useCallback(
+    async (localPaths: string[]) => {
+      setPickerOpen(false)
+      const destDir = cwd
+      for (const localPath of localPaths) {
+        try {
+          const enqueued = await window.api.enqueueUpload({
+            localPath,
+            remoteDir: destDir
+          })
+          if (enqueued.length === 0) {
+            setBrowseError('That folder has no files to upload.')
+          }
+        } catch (error) {
+          setBrowseError(errorMessage(error))
+        }
+      }
+    },
+    [cwd]
+  )
+
   const handleClearFinished = useCallback(async () => {
     await window.api.clearFinishedDownloads()
   }, [])
@@ -370,7 +423,10 @@ export default function App({ canChangePassword }: AppProps) {
         segments={segments}
         onSegmentsChange={setSegments}
         downloadDir={downloadDir}
-        onBrowseServer={() => setPickerOpen(true)}
+        onBrowseServer={() => {
+          setPickerMode('chooseDir')
+          setPickerOpen(true)
+        }}
         onDownloadDirChange={setDownloadDir}
         profiles={profiles}
         selectedProfileId={selectedProfileId}
@@ -412,6 +468,10 @@ export default function App({ canChangePassword }: AppProps) {
           onSelectionChange={setSelected}
           onDownloadSelected={handleDownloadSelected}
           onDownloadEntry={(entry) => enqueue(entry.path)}
+          onUpload={() => {
+            setPickerMode('chooseItems')
+            setPickerOpen(true)
+          }}
         />
 
         <TransferQueue
@@ -428,9 +488,14 @@ export default function App({ canChangePassword }: AppProps) {
       {pickerOpen && (
         <FolderPicker
           initialPath={downloadDir}
+          mode={pickerMode}
           onClose={() => setPickerOpen(false)}
-          onChoose={(path) => {
-            setDownloadDir(path)
+          onChoose={(paths) => {
+            if (pickerMode === 'chooseItems') {
+              void handleUploadSelected(paths)
+              return
+            }
+            setDownloadDir(paths[0])
             setPickerOpen(false)
           }}
         />
diff --git a/src/ui/components/FolderPicker.tsx b/src/ui/components/FolderPicker.tsx
index 05c9156..32e7888 100644
--- a/src/ui/components/FolderPicker.tsx
+++ b/src/ui/components/FolderPicker.tsx
@@ -7,26 +7,31 @@ import { isTextInputFocused } from '../lib/keyboard'
 
 interface FolderPickerProps {
   initialPath: string
+  mode?: 'chooseDir' | 'chooseItems'
   onClose: () => void
-  onChoose: (path: string) => void
+  onChoose: (paths: string[]) => void
 }
 
 export function FolderPicker(props: FolderPickerProps) {
-  const { initialPath, onClose, onChoose } = props
+  const { initialPath, mode = 'chooseDir', onClose, onChoose } = props
   const [roots, setRoots] = useState<DownloadRootMeta[]>([])
   const [listing, setListing] = useState<LocalDirListing | null>(null)
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<string | null>(null)
   const [newFolder, setNewFolder] = useState<string | null>(null)
   const [focusIndex, setFocusIndex] = useState<number | null>(null)
+  const [checked, setChecked] = useState<Set<string>>(new Set())
   const listRef = useRef<HTMLUListElement | null>(null)
 
-  const dirs = useMemo(() => listing?.entries.filter((entry) => entry.isDir) ?? [], [listing])
-  const focusedPath = focusIndex !== null ? dirs[focusIndex]?.path : undefined
+  const rows = useMemo(() => listing?.entries ?? [], [listing])
+  const dirs = useMemo(() => rows.filter((entry) => entry.isDir), [rows])
+  const navRows = mode === 'chooseItems' ? rows : dirs
+  const focusedPath = focusIndex !== null ? navRows[focusIndex]?.path : undefined
 
   const load = useCallback(async (path?: string) => {
     setLoading(true)
     setError(null)
+    setChecked(new Set())
     try {
       const result = await window.api.browseLocalDirs(path)
       setListing(result)
@@ -43,33 +48,40 @@ export function FolderPicker(props: FolderPickerProps) {
   }, [initialPath, load])
 
   useEffect(() => {
-    setFocusIndex(dirs.length > 0 ? 0 : null)
-  }, [dirs])
+    setFocusIndex(navRows.length > 0 ? 0 : null)
+  }, [navRows])
 
   useEffect(() => {
-    const focusDir = (index: number): void => {
-      const buttons = listRef.current?.querySelectorAll('button')
-      buttons?.[index]?.focus()
+    const focusRow = (index: number): void => {
+      const selector = mode === 'chooseItems' ? 'input[type="checkbox"]' : 'button'
+      const targets = listRef.current?.querySelectorAll<HTMLElement>(selector)
+      targets?.[index]?.focus()
     }
     const onKey = (e: KeyboardEvent): void => {
       if (isTextInputFocused()) return
-      if (dirs.length === 0) return
+      if (navRows.length === 0) return
 
       if (e.key === 'ArrowDown') {
         e.preventDefault()
-        const next = Math.min((focusIndex ?? -1) + 1, dirs.length - 1)
+        const next = Math.min((focusIndex ?? -1) + 1, navRows.length - 1)
         setFocusIndex(next)
-        focusDir(next)
+        focusRow(next)
       } else if (e.key === 'ArrowUp') {
         e.preventDefault()
         const next = Math.max((focusIndex ?? 1) - 1, 0)
         setFocusIndex(next)
-        focusDir(next)
+        focusRow(next)
+      } else if (mode === 'chooseItems' && e.key === 'Enter') {
+        const entry = focusIndex !== null ? navRows[focusIndex] : undefined
+        if (entry?.isDir) {
+          e.preventDefault()
+          load(entry.path)
+        }
       }
     }
     window.addEventListener('keydown', onKey)
     return () => window.removeEventListener('keydown', onKey)
-  }, [dirs, focusIndex])
+  }, [navRows, focusIndex, mode, load])
 
   const createFolder = useCallback(async () => {
     if (!listing || !newFolder || !newFolder.trim()) {
@@ -85,21 +97,40 @@ export function FolderPicker(props: FolderPickerProps) {
     }
   }, [listing, newFolder, load])
 
+  const toggleChecked = useCallback((path: string) => {
+    setChecked((prev) => {
+      const next = new Set(prev)
+      if (next.has(path)) next.delete(path)
+      else next.add(path)
+      return next
+    })
+  }, [])
+
   return (
     <Dialog
-      title="Choose download folder"
+      title={mode === 'chooseItems' ? 'Choose files to upload' : 'Choose download folder'}
       width="large"
       onClose={() => onClose()}
       footerButtons={[
         { content: 'Cancel', onClick: () => onClose() },
-        {
-          content: 'Use this folder',
-          buttonType: 'primary',
-          disabled: !listing,
-          onClick: () => {
-            if (listing) onChoose(listing.path)
-          }
-        }
+        mode === 'chooseItems'
+          ? {
+              content:
+                checked.size > 0
+                  ? `Upload ${checked.size} item${checked.size === 1 ? '' : 's'}`
+                  : 'Upload items',
+              buttonType: 'primary',
+              disabled: checked.size === 0,
+              onClick: () => onChoose([...checked])
+            }
+          : {
+              content: 'Use this folder',
+              buttonType: 'primary',
+              disabled: !listing,
+              onClick: () => {
+                if (listing) onChoose([listing.path])
+              }
+            }
       ]}
     >
       {roots.length > 1 && (
@@ -129,13 +160,15 @@ export function FolderPicker(props: FolderPickerProps) {
         <span className="folder-picker__path" title={listing?.path ?? ''}>
           {listing?.path ?? '…'}
         </span>
-        <Button
-          size="small"
-          disabled={!listing || loading}
-          onClick={() => setNewFolder('')}
-        >
-          New folder
-        </Button>
+        {mode !== 'chooseItems' && (
+          <Button
+            size="small"
+            disabled={!listing || loading}
+            onClick={() => setNewFolder('')}
+          >
+            New folder
+          </Button>
+        )}
       </div>
 
       {newFolder !== null && (
@@ -173,7 +206,36 @@ export function FolderPicker(props: FolderPickerProps) {
         ) : (
           <ul ref={listRef}>
             {listing?.entries.map((entry) =>
-              entry.isDir ? (
+              mode === 'chooseItems' ? (
+                <li
+                  key={entry.path}
+                  className={entry.path === focusedPath ? 'is-focused' : undefined}
+                >
+                  <label className="folder-picker__item">
+                    <input
+                      type="checkbox"
+                      aria-label={`Select ${entry.name}`}
+                      checked={checked.has(entry.path)}
+                      onChange={() => toggleChecked(entry.path)}
+                    />
+                  </label>
+                  {entry.isDir ? (
+                    <button type="button" onClick={() => load(entry.path)}>
+                      <span className="file-icon">
+                        <FileDirectoryFillIcon />
+                      </span>
+                      {entry.name}
+                    </button>
+                  ) : (
+                    <span className="folder-picker__file-name">
+                      <span className="file-icon">
+                        <FileIcon />
+                      </span>
+                      {entry.name}
+                    </span>
+                  )}
+                </li>
+              ) : entry.isDir ? (
                 <li
                   key={entry.path}
                   className={entry.path === focusedPath ? 'is-focused' : undefined}
@@ -198,7 +260,11 @@ export function FolderPicker(props: FolderPickerProps) {
         )}
       </div>
 
-      <p className="folder-picker__hint">Files will download into this folder.</p>
+      <p className="folder-picker__hint">
+        {mode === 'chooseItems'
+          ? 'Checked files and folders will upload into the remote folder you are browsing.'
+          : 'Files will download into this folder.'}
+      </p>
     </Dialog>
   )
 }
diff --git a/src/ui/components/RemoteBrowser.tsx b/src/ui/components/RemoteBrowser.tsx
index 4eacff2..adb07c8 100644
--- a/src/ui/components/RemoteBrowser.tsx
+++ b/src/ui/components/RemoteBrowser.tsx
@@ -28,6 +28,7 @@ interface RemoteBrowserProps {
   onSelectionChange: (next: Set<string>) => void
   onDownloadSelected: () => void
   onDownloadEntry: (entry: RemoteEntry) => void
+  onUpload: () => void
 }
 
 export function RemoteBrowser(props: RemoteBrowserProps) {
@@ -44,7 +45,8 @@ export function RemoteBrowser(props: RemoteBrowserProps) {
     onRefresh,
     onSelectionChange,
     onDownloadSelected,
-    onDownloadEntry
+    onDownloadEntry,
+    onUpload
   } = props
 
   const selectedCount = entries.filter((entry) => selected.has(entry.path)).length
@@ -225,6 +227,13 @@ export function RemoteBrowser(props: RemoteBrowserProps) {
           >
             Refresh
           </Button>
+          <Button
+            variant="default"
+            disabled={!connected || loading}
+            onClick={onUpload}
+          >
+            Upload
+          </Button>
           <Button
             variant="primary"
             count={selectedCount || undefined}
diff --git a/src/ui/components/TransferQueue.tsx b/src/ui/components/TransferQueue.tsx
index 6f579bc..cadce0d 100644
--- a/src/ui/components/TransferQueue.tsx
+++ b/src/ui/components/TransferQueue.tsx
@@ -1,4 +1,5 @@
 import { Button, Label, ProgressBar } from '@primer/react'
+import { ArrowDownIcon, ArrowUpIcon } from '@primer/octicons-react'
 import type { TransferProgress, TransferStatus } from '@shared/types'
 import { formatBytes, formatEta, formatPercent, formatSpeed } from '../lib/format'
 
@@ -20,6 +21,14 @@ const STATUS_LABELS: Record<TransferStatus, string> = {
   canceled: 'Canceled'
 }
 
+function statusLabel(transfer: TransferProgress): string {
+  const isUpload = transfer.direction === 'upload'
+  if (transfer.status === 'downloading') {
+    return isUpload ? 'Uploading' : 'Downloading'
+  }
+  return `${isUpload ? 'Upload' : 'Download'} ${STATUS_LABELS[transfer.status].toLowerCase()}`
+}
+
 const STATUS_VARIANTS: Record<
   TransferStatus,
   'accent' | 'success' | 'danger' | 'secondary'
@@ -104,6 +113,7 @@ export function TransferQueue(props: TransferQueueProps) {
             {transfers.map((transfer) => {
               const percent = formatPercent(transfer.transferred, transfer.size)
               const active = transfer.status === 'downloading'
+              const isUpload = transfer.direction === 'upload'
               const canceling = transfer.canceling === true && transfer.status === 'downloading'
               const eta =
                 active && !canceling && transfer.size > 0 && transfer.speedBytesPerSec > 0
@@ -113,10 +123,15 @@ export function TransferQueue(props: TransferQueueProps) {
                 <li key={transfer.id} className="transfer">
                   <div className="transfer__top">
                     <span className="transfer__name" title={transfer.remotePath}>
+                      {isUpload ? (
+                        <ArrowUpIcon aria-label="Upload" />
+                      ) : (
+                        <ArrowDownIcon aria-label="Download" />
+                      )}
                       {baseName(transfer.localPath || transfer.remotePath)}
                     </span>
                     <Label variant={STATUS_VARIANTS[transfer.status]}>
-                      {STATUS_LABELS[transfer.status]}
+                      {statusLabel(transfer)}
                     </Label>
                   </div>
 
@@ -139,8 +154,8 @@ export function TransferQueue(props: TransferQueueProps) {
                     ) : (
                       active && (
                         <span>
-                          {formatSpeed(transfer.speedBytesPerSec)} · {transfer.activeSegments}/
-                          {transfer.segments} segments
+                          {formatSpeed(transfer.speedBytesPerSec)}
+                          {!isUpload ? ` · ${transfer.activeSegments}/${transfer.segments} segments` : ''}
                           {eta ? ` · ~${eta} left` : ''}
                         </span>
                       )
diff --git a/src/ui/index.css b/src/ui/index.css
index 5791816..e90c271 100644
--- a/src/ui/index.css
+++ b/src/ui/index.css
@@ -590,6 +590,11 @@ body {
   background: var(--selected);
 }
 
+.folder-picker__list li.is-focused .folder-picker__file-name {
+  background: var(--selected);
+  border-radius: 6px;
+}
+
 .folder-picker__list li.is-disabled {
   display: flex;
   align-items: center;
@@ -599,6 +604,33 @@ body {
   cursor: default;
 }
 
+.folder-picker__list li:has(.folder-picker__item) {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+
+.folder-picker__list li:has(.folder-picker__item) button {
+  flex: 1;
+}
+
+.folder-picker__item {
+  display: flex;
+  align-items: center;
+  padding: 0 4px;
+  cursor: pointer;
+}
+
+.folder-picker__file-name {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex: 1;
+  padding: 7px 10px;
+  font-size: 13px;
+  color: var(--text);
+}
+
 .folder-picker__hint {
   font-size: 12px;
   color: var(--muted);
diff --git a/src/web/api.ts b/src/web/api.ts
index 0341223..2a10cc3 100644
--- a/src/web/api.ts
+++ b/src/web/api.ts
@@ -14,7 +14,8 @@ import type {
   ResolvedProfile,
   SaveProfileInput,
   SessionStatus,
-  SftpApi
+  SftpApi,
+  UploadEnqueueInput
 } from '@shared/api'
 
 async function request<T>(
@@ -110,6 +111,8 @@ export function createWebApi(): WebApi {
     stat: (path: string) => request<RemoteStat>(`/api/stat?path=${encodeURIComponent(path)}`),
     enqueueDownload: (input: DownloadEnqueueInput) =>
       request<TransferProgress[]>('/api/download', { method: 'POST', body: input }),
+    enqueueUpload: (input: UploadEnqueueInput) =>
+      request<TransferProgress[]>('/api/upload', { method: 'POST', body: input }),
     cancelDownload: async (id: string) => {
       await request('/api/download/cancel', { method: 'POST', body: { id } })
     },
diff --git a/test/downloadManager.test.ts b/test/downloadManager.test.ts
index f39aa09..635fac9 100644
--- a/test/downloadManager.test.ts
+++ b/test/downloadManager.test.ts
@@ -33,6 +33,24 @@ function enqueueInput(overrides: Partial<RcloneEnqueueInput> = {}): RcloneEnqueu
   }
 }
 
+describe('RcloneDownloadManager direction', () => {
+  it('defaults direction to download and round-trips an explicit upload direction through list()', () => {
+    const client = {
+      coreStatsDelete: vi.fn().mockResolvedValue(undefined),
+      copyFileAsync: vi.fn().mockReturnValue(new Promise(() => {}))
+    } as unknown as RcloneClient
+    const manager = new RcloneDownloadManager(client)
+
+    const downloadTransfer = manager.enqueue(enqueueInput())
+    expect(downloadTransfer.direction).toBe('download')
+    expect(manager.list().find((t) => t.id === downloadTransfer.id)?.direction).toBe('download')
+
+    const uploadTransfer = manager.enqueue(enqueueInput({ direction: 'upload' }))
+    expect(uploadTransfer.direction).toBe('upload')
+    expect(manager.list().find((t) => t.id === uploadTransfer.id)?.direction).toBe('upload')
+  })
+})
+
 describe('RcloneDownloadManager cancellation race', () => {
   it('stops and cleans up a job that starts after the user already canceled', async () => {
     const startJob = deferred<number>()
diff --git a/test/localFs.test.ts b/test/localFs.test.ts
index 335c160..0148e54 100644
--- a/test/localFs.test.ts
+++ b/test/localFs.test.ts
@@ -1,8 +1,16 @@
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync, existsSync } from 'node:fs'
+import {
+  mkdtempSync,
+  mkdirSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+  existsSync,
+  symlinkSync
+} from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { listDirs, makeDir, resolvePath, type FsScope } from '../src/server/localFs'
+import { listDirs, listFilesRecursive, makeDir, resolvePath, type FsScope } from '../src/server/localFs'
 
 let base: string
 let confined: FsScope
@@ -113,3 +121,37 @@ describe('makeDir', () => {
     await expect(makeDir(confined, base, 'x')).rejects.toThrow()
   })
 })
+
+describe('listFilesRecursive', () => {
+  it('returns relative paths and sizes for a nested tree, skipping symlinks', async () => {
+    const uploadRoot = mkdtempSync(join(tmpdir(), 'siphon-upload-'))
+    const outsideRoot = mkdtempSync(join(tmpdir(), 'siphon-outside-'))
+    let symlinksCreated = true
+    try {
+      mkdirSync(join(uploadRoot, 'sub'), { recursive: true })
+      writeFileSync(join(uploadRoot, 'a.txt'), '12345')
+      writeFileSync(join(uploadRoot, 'sub', 'b.txt'), '1234567890')
+      writeFileSync(join(outsideRoot, 'secret.txt'), 'shh')
+      try {
+        symlinkSync(join(outsideRoot, 'secret.txt'), join(uploadRoot, 'escape.txt'))
+        symlinkSync(outsideRoot, join(uploadRoot, 'escape-dir'))
+      } catch {
+        // Creating symlinks needs elevated permissions / Developer Mode on Windows.
+        symlinksCreated = false
+      }
+
+      const files = await listFilesRecursive(uploadRoot)
+
+      expect(files.sort((a, b) => a.relPath.localeCompare(b.relPath))).toEqual([
+        { relPath: 'a.txt', size: 5 },
+        { relPath: 'sub/b.txt', size: 10 }
+      ])
+      if (symlinksCreated) {
+        expect(files.some((f) => f.relPath.includes('escape'))).toBe(false)
+      }
+    } finally {
+      rmSync(uploadRoot, { recursive: true, force: true })
+      rmSync(outsideRoot, { recursive: true, force: true })
+    }
+  })
+})
diff --git a/test/uploadRoute.test.ts b/test/uploadRoute.test.ts
new file mode 100644
index 0000000..9b8140e
--- /dev/null
+++ b/test/uploadRoute.test.ts
@@ -0,0 +1,166 @@
+import { describe, expect, it, vi } from 'vitest'
+import { expandUpload } from '../src/server/routes/uploads'
+import type { RcloneClient } from '../src/server/rclone/client'
+import type { RcloneDownloadManager, RcloneEnqueueInput } from '../src/server/rclone/downloadManager'
+import type { TransferProgress } from '../src/shared/types'
+
+const listFilesRecursive = vi.fn()
+
+vi.mock('../src/server/localFs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../src/server/localFs')>()
+  return { ...actual, listFilesRecursive: (...args: unknown[]) => listFilesRecursive(...args) }
+})
+
+function makeManager() {
+  let counter = 0
+  const enqueue = vi.fn((input: RcloneEnqueueInput): TransferProgress => {
+    counter += 1
+    return {
+      id: `t-${counter}`,
+      remotePath: input.displayName,
+      localPath: input.localPath,
+      size: input.size,
+      transferred: 0,
+      speedBytesPerSec: 0,
+      activeSegments: 0,
+      segments: input.segments,
+      status: 'queued',
+      direction: input.direction
+    }
+  })
+  return { enqueue } as unknown as RcloneDownloadManager
+}
+
+describe('expandUpload', () => {
+  it('enqueues one file transfer for a single file', async () => {
+    const client = { deleteRemote: vi.fn() } as unknown as RcloneClient
+    const manager = makeManager()
+
+    const result = await expandUpload(client, manager, {
+      resolved: '/root/file.bin',
+      isDir: false,
+      size: 500,
+      remoteDir: 'dest',
+      jobRemote: '_ul-file'
+    })
+
+    expect(result).toHaveLength(1)
+    expect(manager.enqueue).toHaveBeenCalledWith({
+      srcFs: '/root',
+      srcRemote: 'file.bin',
+      dstFs: '_ul-file:',
+      dstRemote: 'dest/file.bin',
+      displayName: 'file.bin',
+      localPath: '/root/file.bin',
+      size: 500,
+      segments: 1,
+      direction: 'upload',
+      uploadRemoteDir: 'dest',
+      cleanupRemote: '_ul-file'
+    })
+    expect(client.deleteRemote).not.toHaveBeenCalled()
+  })
+
+  it('enqueues one file transfer per recursively listed file in a directory, including nested paths', async () => {
+    const client = { deleteRemote: vi.fn() } as unknown as RcloneClient
+    const manager = makeManager()
+    listFilesRecursive.mockResolvedValueOnce([
+      { relPath: 'a.mkv', size: 10 },
+      { relPath: 'sub/b.mkv', size: 20 }
+    ])
+
+    const result = await expandUpload(client, manager, {
+      resolved: '/root/movies',
+      isDir: true,
+      size: 0,
+      remoteDir: 'dest',
+      jobRemote: '_ul-dir'
+    })
+
+    expect(listFilesRecursive).toHaveBeenCalledWith('/root/movies')
+    expect(result).toHaveLength(2)
+    expect(manager.enqueue).toHaveBeenNthCalledWith(1, {
+      srcFs: '/root/movies',
+      srcRemote: 'a.mkv',
+      dstFs: '_ul-dir:',
+      dstRemote: 'dest/movies/a.mkv',
+      displayName: 'movies/a.mkv',
+      localPath: '/root/movies/a.mkv',
+      size: 10,
+      segments: 1,
+      direction: 'upload',
+      uploadRemoteDir: 'dest',
+      cleanupRemote: '_ul-dir'
+    })
+    expect(manager.enqueue).toHaveBeenNthCalledWith(2, {
+      srcFs: '/root/movies',
+      srcRemote: 'sub/b.mkv',
+      dstFs: '_ul-dir:',
+      dstRemote: 'dest/movies/sub/b.mkv',
+      displayName: 'movies/sub/b.mkv',
+      localPath: '/root/movies/sub/b.mkv',
+      size: 20,
+      segments: 1,
+      direction: 'upload',
+      uploadRemoteDir: 'dest',
+      cleanupRemote: '_ul-dir'
+    })
+    expect(client.deleteRemote).not.toHaveBeenCalled()
+  })
+
+  it('cleans up the cloned remote and returns an empty array when the directory has no files', async () => {
+    const client = { deleteRemote: vi.fn().mockResolvedValue(undefined) } as unknown as RcloneClient
+    const manager = makeManager()
+    listFilesRecursive.mockResolvedValueOnce([])
+
+    const result = await expandUpload(client, manager, {
+      resolved: '/root/empty',
+      isDir: true,
+      size: 0,
+      remoteDir: 'dest',
+      jobRemote: '_ul-empty'
+    })
+
+    expect(result).toEqual([])
+    expect(client.deleteRemote).toHaveBeenCalledWith('_ul-empty')
+    expect(manager.enqueue).not.toHaveBeenCalled()
+  })
+
+  it('cleans up the cloned remote and rethrows when listing the directory fails', async () => {
+    const client = { deleteRemote: vi.fn().mockResolvedValue(undefined) } as unknown as RcloneClient
+    const manager = makeManager()
+    listFilesRecursive.mockRejectedValueOnce(new Error('boom'))
+
+    await expect(
+      expandUpload(client, manager, {
+        resolved: '/root/movies',
+        isDir: true,
+        size: 0,
+        remoteDir: 'dest',
+        jobRemote: '_ul-fail'
+      })
+    ).rejects.toThrow('boom')
+
+    expect(client.deleteRemote).toHaveBeenCalledWith('_ul-fail')
+    expect(manager.enqueue).not.toHaveBeenCalled()
+  })
+
+  it('produces a dstRemote with no leading slash when the remote cwd is the root', async () => {
+    const client = { deleteRemote: vi.fn() } as unknown as RcloneClient
+    const manager = makeManager()
+
+    const result = await expandUpload(client, manager, {
+      resolved: '/root/file.bin',
+      isDir: false,
+      size: 500,
+      remoteDir: '',
+      jobRemote: '_ul-root'
+    })
+
+    expect(result).toHaveLength(1)
+    const call = (manager.enqueue as unknown as { mock: { calls: RcloneEnqueueInput[][] } }).mock
+      .calls[0][0]
+    expect(call.dstRemote).toBe('file.bin')
+    expect(call.uploadRemoteDir).toBe('')
+  })
+})