Frame is a high-performance media conversion utility built on the Tauri v2 framework. It provides a native interface for FFmpeg operations, allowing for granular control over video and audio transcoding parameters. The application leverages a Rust-based backend for concurrent task management and process execution, coupled with a Svelte 5 frontend for configuration and state monitoring.

[!WARNING]
Unsigned Application Notice Since the application is currently unsigned, your operating system will flag it:

• macOS: The system will flag the app and its sidecar binaries with a quarantine attribute. To run the app, remove the attribute manually:

  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

• Container Support: mp4, mkv, webm, mov, gif, mp3, m4a, wav, flac.
• Video Encoders:
  • libx264 (H.264 / AVC)
  • libx265 (H.265 / HEVC)
  • vp9 (Google VP9)
  • prores (Apple ProRes)
  • libsvtav1 (Scalable Video Technology AV1)
  • Hardware Acceleration: h264_videotoolbox (Apple Silicon), h264_nvenc (NVIDIA).
• Audio Encoders: aac, ac3 (Dolby Digital), libopus, mp3, alac (Apple Lossless), flac (Free Lossless Audio Codec), pcm_s16le (WAV).
• Bitrate Control: Constant Rate Factor (CRF) or Target Bitrate (kbps).
• Scaling: Bicubic, Lanczos, Bilinear, Nearest Neighbor.
• Metadata Probing: Automated extraction of stream details (codec, duration, bitrate, channel layout) via ffprobe.
• AI Upscaling: Integrated Real-ESRGAN for high-quality video upscaling (x2, x4).

Architecture & Workflow

• Concurrent Processing: Async task queue manager implemented in Rust (tokio::mpsc) limiting concurrent FFmpeg processes (default: 2).
• Real-time Telemetry: Stream parsing of FFmpeg stderr for accurate progress tracking and log output.
• Preset Management: Configuration persistence for reusable conversion profiles.

Technical Stack

Backend (Rust / Tauri)

• Core: Tauri v2 (Rust Edition 2024).
• Runtime: tokio (Async I/O).
• Serialization: serde, serde_json.
• Process Management: tauri-plugin-shell for sidecar execution (FFmpeg/FFprobe).
• System Integration: tauri-plugin-dialog, tauri-plugin-fs, window-vibrancy.

Frontend (SvelteKit)

• Framework: Svelte 5 (Runes API).
• Build System: Vite.
• Styling: Tailwind CSS v4, clsx, tailwind-merge.
• State Management: Svelte 5 $state / $props.
• Internationalization: Multi-language interface with automatic system language detection.
• Typography: Geist Sans (embedded), Geist Mono (embedded).

Installation

Download Prebuilt Binaries

The easiest way to get started is to download the latest release for your platform (macOS, Windows, or Linux) 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 (see the warning at the top of this file).

Homebrew (macOS)

For macOS users, you can install and update Frame easily using our custom Homebrew Tap:

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

Linux System Requirements

Even when using the AppImage, Frame relies on the system's WebKitGTK and GStreamer libraries for rendering the UI and handling media playback. If the application crashes upon adding a source or the video preview remains blank, you likely need to install the missing GStreamer plugins.

• Ubuntu / Debian:

  sudo apt update
  sudo apt install libwebkit2gtk-4.1-0 gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-libav
  

• Arch Linux:

  sudo pacman -S --needed webkit2gtk-4.1 gst-plugins-base gst-plugins-good gst-libav
  

• Fedora:

  sudo dnf install webkit2gtk4.1 gstreamer1-plugins-base gstreamer1-plugins-good gstreamer1-libav
  

Build from Source

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

1. Prerequisites

• Rust: Install Rust
• Bun (or Node.js): Install Bun
• OS Dependencies: Follow the Tauri prerequisites for your operating system.

2. Setup Project

Clone the repository and install dependencies:

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

3. Setup Binaries

Frame requires FFmpeg/FFprobe sidecar binaries and Real-ESRGAN sidecar assets for AI upscaling. We provide scripts to fetch the correct versions for your platform automatically:

bun run setup:ffmpeg
bun run setup:upscaler

4. Build or Run

• Development:

  bun tauri dev
  

• Production Build:

  bun tauri build
  

Usage

1. Input: Use the system dialog to select files.
2. Configuration:
   • Source: View detected file metadata.
   • Output: Select container format and output filename.
   • Video: Configure codec, bitrate/CRF, resolution, and framerate.
   • Audio: Select codec, bitrate, channels, and specific tracks.
   • Presets: Save and load reusable conversion profiles.
3. Execution: Initiates the conversion process via the Rust backend.
4. Monitoring: View real-time logs and percentage counters in the UI.

Star History

Acknowledgments & Third-Party Code

• Real-ESRGAN: Copyright (c) 2021, Xintao Wang. Licensed under BSD 3-Clause.
• FFmpeg: Licensed under GPLv3.

License

GPLv3 License. See LICENSE for details.