vidcord is a free, open-source Discord video compressor for Windows, macOS, and Linux. Compress videos for Discord's upload size limits without uploading them to a website: choose a 10 MB, 25 MB, 50 MB, 100 MB, or 500 MB target, trim the clip, and export a Discord-ready .mp4 from your desktop. GIF Mode creates animated .gif exports for Discord's 10 MB Free and 50 MB Nitro Basic tiers.

vidcord supports MP4, MOV, MKV, AVI, WebM, FLV, WMV, and other formats handled by your system FFmpeg install. It wraps FFmpeg with hardware-accelerated encoding (NVIDIA NVENC, AMD AMF, Intel Quick Sync, Linux VAAPI, Apple VideoToolbox), automatic bitrate calculation, strict output size checks, output FPS controls, and platform-native installers. Built with Tauri 2 (Rust + React). 100% local - no accounts, no uploads, no telemetry.

At a glance — Free Discord video compressor for Windows 10/11, macOS 11+, and Linux · x86_64 + aarch64 · Platform-native installers · Compresses MP4, MOV, MKV, AVI, WebM, FLV, WMV to .mp4 · Targets Discord's current 10 / 50 / 100 / 500 MB limits plus a legacy 25 MB size · Hardware-accelerated (NVENC / AMF / QSV / VAAPI / VideoToolbox) · Requires system FFmpeg on PATH · MIT licensed · Works fully offline.

• Why vidcord
• Best for
• Features
• Screenshots
• Download vidcord
• FFmpeg setup
• Usage
• Keyboard shortcuts
• Hardware acceleration
• Building from source
• Project layout
• Troubleshooting
• FAQ
• Contributors
• Contributing
• License
• Acknowledgements

Discord's current upload limits are 10 MB (free), 50 MB (Nitro Basic / Boost Level 2), 100 MB (Boost Level 3), and 500 MB (Nitro). vidcord also keeps a legacy 25 MB target for users who still want that size. It picks a target bitrate for the clip length you want, lets you choose from the video encoders exposed by your FFmpeg install, and drops the result in your Downloads folder by default. You can instead save beside the imported clip, choose a persistent custom folder, or have vidcord ask for a location when the encode finishes. By default, the completed file itself is copied to the system clipboard; if that fails, vidcord reveals it in the platform file manager. It can also be set to always reveal the output. It verifies the finished file against your selected size limit and automatically retries with CPU encoding and safer bitrates when FFmpeg's first pass lands too large.

• Platform-native packaging. Tauri uses the system WebView (Edge on Windows, WebKit on macOS/Linux) instead of bundling Chromium. Package size varies by platform: Windows installers are the smallest, macOS ships a universal DMG, and the self-contained Linux AppImages are substantially larger.
• Native-speed encoding. Hardware encoders auto-detected: NVENC, AMF, QSV, VAAPI, VideoToolbox.
• No telemetry, no accounts, no uploads. Files never leave your machine.

• Five quality presets covering current Discord tiers plus a legacy target:
  • 10 MB @ 480p — Discord free tier
  • 25 MB @ 480p — legacy convenience target (not a current Discord tier)
  • 50 MB @ 720p — Nitro Basic / Boost Level 2
  • 100 MB @ 1080p — Boost Level 3 or Clips Bypass
  • 500 MB @ native — Nitro Full
• GIF Mode — export an optimized animated GIF for the 10 MB Discord Free or 50 MB Nitro Basic tier at 15, 30, or Discord-safe maximum 50 FPS. Video-only encoder, audio, and advanced controls are hidden while GIF Mode is active. Higher frame rates trade spatial detail for motion, and oversized GIFs are retried at progressively lower visual complexity without changing the selected FPS.
• Advanced mode — custom target size (MB), output resolution, FPS, and any FFmpeg video encoder string, with autocomplete from the encoders your installed FFmpeg exposes. Leave target size empty to encode at the source video's bitrate without enforcing a file-size limit.
• Output FPS controls — standard mode can leave FPS unchanged or cap it at 24, 30, or 60 FPS, hiding options above the source frame rate. Advanced mode accepts a custom FPS value, or an empty field shown as Off for no change.
• Completion actions — copy the finished output file itself to the system clipboard by default, with an automatic reveal fallback, or always reveal it in Explorer/Finder instead.
• Trim timeline with fine-grained handles, draggable playhead, snap controls, zoom, pan, undo/redo, and optional looped playback.
• In-app playback preview of the trimmed segment on Windows and macOS, starting from the current playhead when it is inside the selected range.
• Responsive scrub previews with display-sized filmstrip/frame thumbnails, sparse thumbnail generation for long videos, playhead-aware fallback preview clips, and hardware-accelerated preview clips where FFmpeg supports them.
• Linux preview fallback — WebKitGTK live video scrubbing and trim playback are disabled for stability; FFmpeg-generated filmstrip and individual-frame previews remain available while scrubbing.
• Hardware acceleration, auto-detected at startup:
  • NVIDIA NVENC (h264_nvenc, hevc_nvenc)
  • AMD AMF (h264_amf, hevc_amf)
  • Intel Quick Sync (h264_qsv, hevc_qsv)
  • Linux VAAPI (h264_vaapi, hevc_vaapi)
  • macOS VideoToolbox (h264_videotoolbox, hevc_videotoolbox)
• Three ways to open a video: drag-and-drop onto the window, "Open with vidcord" from Explorer/Finder, or the in-app Browse button.
• Compact fixed-size window — stays fixed at 460×690, with standard and advanced controls fitted into the app surface without scrollbars.
• System-matched macOS chrome — the native title bar follows macOS Light and Dark appearances together with the app surface.
• Remove audio — strip the audio track to reclaim space.
• Strict size checks with bounded retries — finished files are measured against the selected target. Hardware jobs use at most four full attempts and CPU jobs use at most two, including measured bitrate correction and CPU fallback before reporting the smallest result.
• Real-time progress with ETA, current attempt number, encoder, and bitrate parsed from FFmpeg's stderr.
• Race-safe cancellation — cancelling keeps the job owned until FFmpeg exits, prevents another encode from starting early, and removes partial output.
• Collision-safe auto-named output — direct destination modes atomically reserve name-vidcord.mp4 before encoding and bump -1, -2, … if needed, even if another file appears at the intended path just before compression starts.
• Flexible output location — save to Downloads, beside the imported clip, to a remembered custom folder, or choose a filename after compression finishes.
• Verified in-app updates — update checks run after startup settles and no more than once every six hours. After approval, vidcord streams the matching installer to Downloads, validates its size, completeness, and GitHub-published SHA-256 digest, chooses an unused filename, and opens it.
• Automated FFmpeg setup assistance — Windows installers offer winget, and first launch prompts to install through the platform package manager. No FFmpeg binaries are bundled with vidcord.
• Cross-platform installers: Windows NSIS (x86_64 + aarch64), macOS universal .dmg, Linux .AppImage (x86_64 + aarch64).

MP4, MOV, MKV, AVI, WebM, FLV, WMV, and any other container / codec combination your system FFmpeg can demux. Standard and Advanced mode output is .mp4 — H.264 (AVC) by default or H.265 (HEVC) if you pick an hevc_* encoder. GIF Mode creates an animated .gif.

Main window	Advanced mode	GIF mode

Output file	Windows context menu	macOS Finder

Grab the latest installer for your platform from the releases page:

→ Download latest release

You still need FFmpeg. vidcord does not bundle FFmpeg. See the next section. The installer or first launch can offer to install it for you.

vidcord shells out to the system ffmpeg and ffprobe binaries, which must be on PATH. If they aren't, vidcord can prompt on first launch and attempt a package-manager install: winget on Windows, brew on macOS, or apt/dnf/pacman on Linux with privilege confirmation.

winget install Gyan.FFmpeg

The vidcord installer and first-launch setup can run this for you when FFmpeg is missing. vidcord recognizes WinGet's FFmpeg install directory immediately, even when the running process has not received the updated PATH.

vidcord tries the same winget setup first. If the package is unavailable for your ARM64 PC, see FFMPEG_SETUP.md for the community build and manual PATH steps.

brew install ffmpeg

sudo apt install ffmpeg        # Debian / Ubuntu
sudo dnf install ffmpeg        # Fedora (needs RPM Fusion)
sudo pacman -S ffmpeg          # Arch / Manjaro

For more distros, manual installs, or troubleshooting, read FFMPEG_SETUP.md.

1. Open a video — drop it onto the window, right-click → Open with vidcord from Explorer/Finder, or click Browse File.
2. Choose where to save — use Downloads, the imported clip's folder, a remembered custom folder, or Ask when done. Choose whether completion copies the output file or reveals it.
3. Pick a preset — 10/25/50/100/500 MB, or flip on Advanced mode for a custom target size, resolution, FPS, and encoder. Leave the advanced size empty to use the source bitrate without a file-size limit. Standard mode can also cap output FPS at 24, 30, or 60 when those values do not exceed the source frame rate.
4. Trim (optional) — drag the handles or use I / O to stamp the playhead. Space plays the selected range from the current playhead when it is inside the trim.
5. Toggle Remove Audio to strip audio if you need more video bitrate.
6. Click Compress. Progress shows the current attempt, encoder, bitrate, and ETA. When it's done, vidcord reports the final output size and runs your selected completion action.

Output goes to ~/Downloads/<original-name>-vidcord.mp4 by default, with -1, -2, … appended if the name is taken. The selected destination mode, custom folder, and completion action are saved for the next launch.

At startup vidcord runs ffmpeg -encoders, detects compatible CPU and hardware encoders, and lets you choose the encoder to use. Advanced mode can accept any FFmpeg video encoder string; the Encoders dialog shows what your installed FFmpeg exposes.

On Linux, vidcord probes /dev/dri/renderD* once per session to pick the right VAAPI device, and sets LIBVA_DRIVER_NAME=radeonsi for AMD systems.

git clone https://github.com/cyroz1/vidcord
cd vidcord
npm install
npm run tauri dev

Vite serves the frontend on :5173 and Tauri launches the window with hot-reload.

npm run tauri build

Installers / bundles land in src-tauri/target/release/bundle/.

npm run lint                                            # eslint src
npm run typecheck                                       # tsc --noEmit
npm test                                                # vitest
npm run format                                          # prettier --write src
cargo fmt   --check --manifest-path src-tauri/Cargo.toml
cargo clippy --manifest-path src-tauri/Cargo.toml --tests -- -D warnings
cargo test  --manifest-path src-tauri/Cargo.toml
(cd src-tauri && cargo audit)                           # respects .cargo/audit.toml

CI treats any clippy warning as an error and also runs npm/Rust audit, version, asset, lint, typecheck, test, and build checks. Keep new Rust code warning-clean.

• release — LTO, codegen-units = 1, strip, panic = abort. Used for tagged v* releases.
• ci — inherits release with lto = false, codegen-units = 4, opt-level = 1. Used by non-tag CI builds for speed.
• dev.package."*" — third-party deps built at opt-level = 1 so FFmpeg stderr parsing and regex stay responsive in tauri dev while our own crate stays unoptimised for fast incremental compiles.

.github/workflows/build.yml runs five jobs: a shared frontend build, Rust lint + audit, clippy + tests, a 5-way bundle matrix (Windows x86_64/aarch64, macOS universal, Linux x86_64/aarch64), and a release job that extracts the matching CHANGELOG.md section and drafts a GitHub release on v* tags.

src/                       React + TypeScript frontend
  App.tsx                  Root component — trim UI, preset wiring, compress flow
  ipc.ts                   Typed wrappers around Tauri invoke() commands
  components/              PreviewPane, TrimTimeline, ProgressSection, Toast, EncodersDialog
  hooks/                   useCompression, useEncoders, useSettings, useToasts
  __tests__/               Vitest tests (node env, Tauri APIs mocked)

src-tauri/                 Rust backend
  src/lib.rs               Tauri builder, plugins, Linux env shims, file-open routing
  src/ffmpeg.rs            Probe / preview / filmstrip / VAAPI discovery + caches
  src/ffmpeg/encoders.rs   FFmpeg encoder detection + encoder cache invalidation
  src/gpu.rs               Vendor detection (lspci / system_profiler / CIM)
  src/settings.rs          Typed settings persisted via atomic rename
  src/commands/            #[tauri::command] handlers (compression, encoders, files, updates)
  tauri.conf.json          Product config, CSP, file associations, bundle targets

.github/workflows/         App build/release workflow plus site validation workflow
scripts/                   Version, asset, and site structured-data checks

A deeper architectural tour — IPC boundary, file-open race conditions, cache layout, settings migration — lives in AGENTS.md.

"FFmpeg not found" after installing it. Use Retry in vidcord. On Windows, the app checks the standard WinGet aliases and Gyan.FFmpeg package directory directly. For other install methods, quit vidcord fully and relaunch it so the new PATH is loaded; if a newly opened terminal cannot run both ffmpeg -version and ffprobe -version, repair the install or its PATH entry using the setup guide.

The output file exceeds the target size. vidcord now retries oversized outputs automatically, first at a lower bitrate with the selected encoder and then with CPU encoding when needed. If it still cannot hit the requested limit, the status line reports the smallest oversized result. Try Remove audio, drop to a lower resolution in Advanced mode, or pick hevc_* (H.265) if your recipient can decode it.

Live scrubbing or trim playback is unavailable on Linux. These controls are disabled because WebKitGTK's GStreamer playback path can crash the renderer on some Linux systems. The timeline still provides FFmpeg-generated filmstrip and individual-frame previews while scrubbing.

Windows console flashes during a compress. Shouldn't happen — every FFmpeg invocation sets CREATE_NO_WINDOW (0x08000000). If you see it, open an issue with the vidcord log (%LOCALAPPDATA%\vidcord\vidcord.log).

Where do settings live?

Logs live alongside settings.json as vidcord.log (rotated at 5 MB).

vidcord is built specifically for Discord uploads. It offers one-click 10 MB, 25 MB, 50 MB, 100 MB, and 500 MB targets, including a legacy 25 MB option alongside Discord's current limits, and runs locally on Windows, macOS, and Linux, and uses FFmpeg instead of uploading your video to a third-party compression website.

Open the video in vidcord, choose the 10 MB preset, trim to the part you want to share, optionally enable Remove Audio, and click Compress. vidcord calculates the target bitrate from the clip length, verifies the finished file size, and retries with safer settings if the output is too large.

Yes. vidcord is released under the MIT License with the full source on GitHub. There are no paid tiers, accounts, or trials.

No. vidcord runs video processing entirely on your computer — no compression server, no account, and no telemetry. The app automatically checks the GitHub Releases API for updates at most once every six hours, deferred for eight seconds after startup. It only downloads an installer after you choose to install an available update. The website also requests public release metadata from GitHub and an aggregate download count from Shields.io; no video data is included in either request. Compression itself works without an internet connection.

When an update is available, vidcord offers the matching Windows, macOS, or Linux installer and keeps the GitHub release page as a fallback. After you approve the download, the app streams it to Downloads, enforces size and completeness limits, compares the bytes with the SHA-256 digest published in GitHub release metadata, and only then gives the installer an unused filename and opens it. This integrity check does not replace platform code signing.

• Free accounts: 10 MB per file. The former 25 MB value remains available in vidcord as a legacy target, but Discord no longer documents it as a current account tier.
• Server Boost Level 2 / Nitro Basic uploads: 50 MB.
• Server Boost Level 3 uploads: 100 MB (also the ceiling for the Clips Bypass trick).
• Nitro Full: 500 MB per file.

vidcord ships one preset per tier and picks a resolution cap that usually still looks reasonable at that bitrate.

Any container your system FFmpeg can demux: MP4, MOV, MKV, AVI, WebM, FLV, WMV, and more. Output is always .mp4 (H.264 by default, H.265 if you pick an hevc_* encoder in Advanced mode).

Yes. MP4 is the main output format and one of the common supported input formats. You can open an existing .mp4, trim it, choose a Discord size limit, and export a smaller .mp4 ready to upload.

No. The 10 MB preset targets free Discord accounts. The 25 MB option is a legacy convenience target rather than a current Discord account tier; the 50 / 100 / 500 MB presets cover Nitro Basic, boosted servers, and Nitro.

Yes. Standard mode offers Off, 24, 30, and 60 FPS, and hides choices above the source video's frame rate. Advanced mode lets you enter any positive FPS value, or leave the Off field empty to keep the original cadence.

vidcord calculates the right target bitrate for your clip length and size limit, detects supported CPU and hardware encoders for you to choose from, remembers your selection, streams attempt details and ETA back while FFmpeg runs, verifies the final file size, retries oversized results, handles visual trimming, and writes to a predictable, auto-incremented path in Downloads, beside the source clip, or in a remembered custom folder. It can also ask for the final filename after compression. The completed file can then be copied as a file object to the system clipboard or revealed in the platform file manager. Under the hood it's still FFmpeg — Advanced mode exposes the encoder string so you can override any of it.

Not currently. Hitting a specific target size under Discord's limits requires re-encoding at a calculated bitrate; stream-copy wouldn't guarantee the output fits.

Yes. vidcord ships as an .AppImage for x86_64 and aarch64 and is tested on GNOME, KDE Plasma, LXQt, Sway, and Hyprland on both X11 and Wayland. Hardware-accelerated encoding uses VAAPI via /dev/dri/renderD*. Live video scrubbing and trim playback are disabled on Linux because WebKitGTK's GStreamer playback path can crash the renderer on some systems. FFmpeg-generated filmstrip and frame previews remain available while scrubbing.

No — vidcord is a GUI app. For scripted workflows, call FFmpeg directly; the presets in vidcord are just wrappers around standard FFmpeg arguments.

Yes. Once vidcord and FFmpeg are installed, no internet connection is needed to compress a video. Update lookup, installer downloads, and the website's live download count simply remain unavailable while offline.

• Windows 10 or 11 (x86_64 or aarch64) with the WebView2 Runtime (pre-installed on Windows 11).
• macOS 11 (Big Sur) or newer, Intel or Apple Silicon.
• Linux with glibc and WebKit2GTK 4.1 (almost every modern desktop distribution).
• Disk space for the app package and FFmpeg; exact sizes vary substantially by platform and package source.

• wvbzy (WubzyFN on X) — suggested the output destination and completion action features.

Issues and PRs are welcome. Before opening a PR:

1. Run all quality gates above — CI is strict about clippy and formatting.
2. Add a ## vX.Y section at the top of CHANGELOG.md for user-visible changes. The release workflow uses it as the GitHub release body.
3. Don't bump version numbers casually. package.json, src-tauri/Cargo.toml, and src-tauri/tauri.conf.json must stay in sync, and any bump triggers a release the next time a tag is pushed.

Read AGENTS.md for the architectural invariants you're expected not to break (Tauri command registration, blocking work and spawn_blocking, the three file-open delivery paths, Linux env shims for KDE / LXQt / Sway / Hyprland, cache invalidation rules).

vidcord is released under the MIT License. FFmpeg is a separate dependency and is licensed under the LGPL/GPL by its own authors — vidcord invokes the ffmpeg and ffprobe binaries on your system but does not redistribute them.

• FFmpeg — the actual video compression.
• Tauri — cross-platform desktop shell.
• React + Vite — frontend.
• YABDP4Nitro — documented the Discord Clips size-limit quirk that the 100 MB preset targets.