Frame

Frame is a native media conversion utility built in Rust. It provides a desktop interface for FFmpeg operations, with granular control over video, audio, image, subtitle, and metadata settings. The application uses a GPUI-CE front end and a reusable Rust conversion core for FFmpeg argument generation, source probing, compatibility validation, task control, and progress parsing.

Warning

Unsigned Application Notice Since the application is currently not Developer ID or certificate signed, your operating system may flag it:

• macOS: Release artifacts are ad-hoc signed but not notarized. The system can flag the app and bundled binaries with a quarantine attribute. To run the app, remove the attribute manually after installing it:

  xattr -dr com.apple.quarantine /Applications/Frame.app

• Windows: Windows SmartScreen may prevent the application from starting. Click "More info" and then "Run anyway" to proceed.

GitHub Sponsors

If Frame helps you, consider supporting the project on GitHub Sponsors:

Sponsor Frame

Current funding goals:

• Apple Developer Program: $99/year to sign and notarize macOS builds.
• Microsoft code-signing certificate: estimated $300-$700/year to sign Windows builds and reduce SmartScreen friction.

Sponsor contributions are used first for these release-signing costs.

See GitHub Sponsors for full sponsorship details, tier suggestions, and a launch checklist.

Features

Media Conversion Core

• Media Types: Video, audio, and image sources.
• Supported Source Files:
  • Video: mp4, mov, mkv, avi, webm, gif
  • Audio: mp3, m4a, wav, flac
  • Image: png, jpg, jpeg, webp, bmp, tif, tiff, avif, heic, heif
• Supported Output Formats:
  • Video: mp4, mkv, webm, mov, gif
  • Audio: mp3, m4a, wav, flac
  • Image: png, jpg, webp, bmp, tiff
• Video Encoders:
  • libx264 (H.264 / AVC)
  • libx265 (H.265 / HEVC)
  • vp9 (Google VP9)
  • prores (Apple ProRes)
  • libsvtav1 (SVT-AV1)
  • gif palette output
  • Hardware Acceleration: macOS bundles include VideoToolbox encoders (h264_videotoolbox, hevc_videotoolbox); Windows bundles include NVIDIA NVENC encoders (h264_nvenc, hevc_nvenc, av1_nvenc). Linux bundles use software encoders.
• Image Encoders: png, mjpeg (JPEG), libwebp (WebP), bmp, tiff.
• Audio Encoders: aac, ac3, libopus, mp3, alac, flac, pcm_s16le, plus optional libfdk_aac when available.
• Bitrate Control: CRF, target bitrate, audio VBR where supported, and codec-specific presets.
• Video Processing: Resolution presets, custom dimensions, FPS conversion, pixel format selection, scaling, crop, rotate, flip, and image overlay.
• Video Filters: Brightness, contrast, saturation, gamma, hue, color temperature, sharpen, Gaussian blur, denoise, deband, vignette, grayscale, and deinterlace controls.
• GIF Controls: Frame rate, color count, dithering, and loop count.
• Audio Controls: Codec, bitrate, VBR quality, channel layout, volume, and per-track selection.
• Audio Filters: Normalize, limiter, compressor, bass, treble, high-pass, low-pass, noise reduction, de-esser, and stereo width controls.
• Subtitles: Stream selection, .srt / .ass / .vtt source filtering, burn-in subtitle file selection, font, size, color, outline color, and position controls.
• Metadata: Preserve, clean, or replace metadata fields such as title, artist, album, genre, date, and comment.
• Metadata Probing: Automated source inspection through ffprobe.

Architecture & Workflow

• Native UI: GPUI-CE application shell, custom titlebar, workspace/logs views, settings panels, and shared UI primitives.
• Shared Conversion Core: frame-core owns FFmpeg arguments, media rules, probing types, filter construction, and validation logic.
• Concurrent Processing: Rust task controller for queueing and limiting simultaneous FFmpeg processes.
• Real-time Telemetry: FFmpeg progress and log events are parsed and shown in the app while conversions run.
• Runtime Binaries: Local development uses platform-specific FFmpeg and FFprobe binaries under frame-app/resources/binaries/. Native bundles include those tools and detect encoder capabilities from the bundled FFmpeg at startup.

Technical Stack

Native Application

• Language: Rust Edition 2024.
• UI: GPUI-CE.
• Native Dialogs: rfd, with extension filtering for supported media and subtitle files.
• Assets: Embedded SVG icons, bundled Overused Grotesk font, and native app icon resources for macOS, Windows, and Linux packages.

Conversion Core

• Runtime Tools: FFmpeg and FFprobe.
• Serialization: serde, serde_json.
• Error Handling: thiserror.
• Media Rules: Shared JSON compatibility matrix consumed by Rust code.

Installation

Download Prebuilt Binaries

The easiest way to get started is to download the latest release for your platform directly from GitHub.

Download Latest Release

Note: Since the application is not yet code-signed, you may need to manually approve it in your system settings.

Automatic Updates

Native release builds include a signed-manifest updater. Frame checks the latest GitHub Release manifest, verifies its Ed25519 signature and the SHA-256 hash of the selected platform asset, then installs through a small bundled helper.

WinGet (Windows)

Frame is available in the official WinGet repository under the 66HEX.Frame identifier.

winget install --id 66HEX.Frame -e

To update:

winget upgrade --id 66HEX.Frame -e

Homebrew (macOS)

For macOS users, Frame is available through the custom Homebrew tap:

brew tap 66HEX/frame
brew install --cask frame

Flathub (Linux)

The production Flatpak is distributed through Flathub under io.github._66HEX.Frame. The Flathub build uses FFmpeg, FFprobe, codecs, and media libraries from the Freedesktop runtime instead of bundled sidecar media tools.

flatpak install flathub io.github._66HEX.Frame

To update:

flatpak update io.github._66HEX.Frame

Build from Source

If you prefer to build the application yourself or want to contribute, follow these steps.

1. Prerequisites

• Rust: Install Rust
• Platform toolchain: a C/C++ build toolchain and native desktop libraries required by Rust and GPUI-CE on your operating system.

2. Clone the Repository

git clone https://github.com/66HEX/frame.git
cd frame

3. Setup Runtime Binaries

Frame requires FFmpeg and FFprobe runtime binaries. Release and development tasks download the platform-specific tools into ignored local runtime paths. To prepare them manually:

cargo xtask setup-ffmpeg

4. Run or Build

• Development:

  cargo xtask run

• Production Build:

  cargo xtask build --release

• Regenerate release workflows:

  cargo xtask workflows

• macOS DMG:

  cargo install cargo-bundle
  cargo xtask bundle macos

• Linux tarball with .desktop metadata and hicolor icons:

  cargo xtask bundle linux

• Windows installer:

  cargo xtask bundle windows

  The release binary embeds the Frame .ico resource during the normal Cargo build so Explorer and the taskbar can resolve the application icon.

Development Checks

Run the main checks before submitting changes:

cargo xtask ci

Star History

Acknowledgments & Third-Party Code

• FFmpeg: Licensed under GPLv3.
• GPUI-CE: Native Rust UI framework used by Frame.

License

GPLv3 License. See LICENSE for details.