[opensourcedex]

Clypra is a free, open source photo & video editors project written in TypeScript and released under MIT. It has 3,240 GitHub stars, 325 forks and 20 open issues, and was last pushed 10 hours ago. On this registry it ranks #20 of 22 tracked projects in Photo & Video Editors, with 5 head-to-head comparisons available.

What is Clypra?

Clypra is a free, MIT-licensed, hardware-accelerated video editor built on Rust, Tauri v2, and React 19, aimed at editors, video engineers, and open-source contributors who want frame-accurate timeline editing and GPU-native rendering on desktop and mobile without watermarks, paywalls, feature limits, or subscriptions.

What it is

Clypra is a native desktop video editor whose core is written in Rust and packaged with Tauri v2, with a React 19 and TypeScript frontend on top. The frontend holds the Timeline UI, the Preview Canvas, and the Filmstrip Cache, and it talks to the Rust backend through the Tauri IPC layer. The backend owns the Decoder Pool with its LRU cache, the Frame Decoder, and the Export Pipeline. The project lives in the Tauri ecosystem and uses wgpu-based GPU rendering, as reflected in its topics: tauri-app, tauri-react, tauri-v2, wgpu, wgpu-native, and wgpu-rs.

The concrete problem it solves is the cost and lock-in of professional editing tooling. The README states that everything is 100 percent free and open source, with no watermarks, no paywalls, no feature limits, and no subscriptions, so it replaces the paid, closed-source editing application tier that editors otherwise rent per month. It also targets a performance problem: sub-10ms frame decoding is achieved through native Rust decoding plus GPU decode paths (VideoToolbox, D3D11VA, VAAPI) and FFmpeg, which keeps scrubbing and playback responsive on ordinary hardware rather than requiring a workstation.

Key capabilities

  • Multi-track timeline with frame-accurate trimming, multi-layer track arrangement, and complete undo/redo history.
  • Hardware-accelerated engine with sub-10ms decoding latency, a Decoder Pool backed by an LRU cache, and GPU decoding through VideoToolbox, D3D11VA, and VAAPI alongside FFmpeg.
  • High-fidelity audio with real-time peak and RMS waveform rendering, frame-accurate AV sync, and per-clip volume controls.
  • Text and visual compositing with custom text styling, animated overlays, filters, and real-time canvas previews.
  • Multi-format import and export covering MP4, MOV, WebM, MKV, MP3, WAV, and PNG, with ProRes and H.264 export.
  • Production-only performance telemetry collector that records decode microseconds, compose microseconds, P95 seek latency, dropped frame counts, OS family, and GPU vendor and model, with adaptive sampling at 1 percent during smooth 60 FPS playback and 100 percent when dropped frames exceed 5 percent or a driver fallback occurs.
  • Portability across platforms: macOS on Apple Silicon and Intel, Windows 10 and 11, and Linux as desktop targets, with iOS and Android reachable through Capacitor.

Who uses it and how

  • Individual editors and small studios cutting on macOS, Windows, or Linux who need ProRes or H.264 delivery without a subscription.
  • Editors working in mobile or hybrid setups, using the Capacitor build to reach iOS and Android.
  • Contributors extending the React 19 frontend or the Rust and FFmpeg backend; the README marks pull requests as welcome and points to CONTRIBUTING.md.
  • Engineers diagnosing stutter and GPU driver regressions, who review aggregated metrics in the Clypra Studio Admin Console at /studio/admin, served from the separate clypra-studio repository and specified in docs/performance-telemetry.md.
  • Sponsors supporting the project through the GitHub Sponsors link listed in SPONSORS.md.

Getting started

Installation and Development instructions live in the README, and the hosted project page is at https://clypra.abdulkabirmusa.com. No published package name, Docker image, or compose file appears in the facts, so getting started means building from source with the Rust and Tauri toolchain plus the React frontend.

How it compares

No paid products and no similar open-source tools are named in the facts for this project, so Clypra stands alone in this registry in that respect, with no direct comparison available from the source data.

When to use it — and when not to

A self-hoster must build and maintain the Rust and Tauri toolchain, the FFmpeg dependency, the React 19 frontend, and working GPU drivers for VideoToolbox, D3D11VA, or VAAPI, since no packaged release or container image is named. The production telemetry collector sends timing data, OS family, and GPU vendor and model to a hosted analysis hub, so teams with strict no-telemetry or no-external-endpoint policies should weigh that before adopting, even though the README states that no video frames, media assets, project titles, file paths, or personal identities are ever collected. Anyone wanting a fully managed, hosted editing service rather than a locally built application is not the intended user.

project readme (upstream, from github) — read inline

Clypra

Clypra Showcase Banner

Professional video editing—free and open source forever.

A hardware-accelerated video editor built on Rust, Tauri v2, and React 19. Sub-10ms frame decoding, GPU-native rendering, and a frame-accurate timeline — all free and open source under MIT.

License: MIT PRs Welcome GitHub issues GitHub stars GitHub Sponsors

Features • Architecture • ⚡ Performance Telemetry • Installation • Development • Contributing

Overview

Clypra is a free, open-source video editor (MIT License) with professional-grade features. Everything is 100% free and open source—no watermarks, no paywalls, no feature limits, and no subscriptions required.

Supported Platforms

  • Desktop: macOS (Apple Silicon & Intel), Windows 10/11, Linux
  • Mobile: iOS & Android (via Capacitor)

Key Features

  • 🎬 Multi-Track Timeline & Editing — Frame-accurate trimming, multi-layer track arrangement, and complete undo/redo history.
  • ⚡ Hardware-Accelerated Engine — Sub-10ms decoding latency powered by native Rust, GPU decoding (VideoToolbox, D3D11VA, VAAPI), and FFmpeg.
  • 🎵 High-Fidelity Audio & Waveforms — Real-time peak + RMS waveform rendering, frame-accurate AV sync, and clip volume controls.
  • 🎨 Text & Visual Compositing — Custom text styling, animated overlays, filters, and real-time canvas previews.
  • 📦 Multi-Format Import & Export — Support for MP4, MOV, WebM, MKV, MP3, WAV, PNG, and high-quality ProRes/H.264 export.
  • 🛡️ Zero-Overhead Performance Telemetry — Production-only frame timing analysis to optimize driver compatibility and cross-OS rendering with zero PII.

⚡ Production Performance Telemetry & Privacy

To ensure stutter-free 60 FPS playback and diagnose edge-case GPU driver regressions across diverse hardware configurations, Clypra includes a lightweight, non-blocking telemetry collector:

  • What We Collect: High-level numerical timings (decode $\mu$s, compose $\mu$s, P95 seek latency, dropped frame counts, OS family, and GPU vendor/model).
  • Strict Privacy (Zero PII): Zero video frames, media assets, project titles, file paths, or personal user identities are ever accessed or sent.
  • Adaptive Sampling: Smooth 60 FPS playback is sampled at 1%, while dropped frames ($>5%$) and driver fallbacks are captured at 100% to isolate regressions without impacting playback frame pacing.
  • Analysis Hub: Aggregated performance metrics are analyzed by engineers in the Clypra Studio Admin Console (/studio/admin).

For technical details, see the Performance Telemetry Specification.

Architecture

Clypra is built with a native Rust/Tauri v2 core for hardware video operations, coupled with a React 19 frontend.

┌────────────────────────────────────────────────────────────┐
│                    Frontend (React/TS)                     │
│  ┌──────────────┐  ┌───────────────┐  ┌─────────────────┐  │
│  │  Timeline UI │  │ Preview Canvas│  │ Filmstrip Cache │  │
│  └──────┬───────┘  └──────┬────────┘  └────────┬────────┘  │
│         └─────────────────┴────────────────────┘           │
│                           │                                │
│                    Tauri IPC Layer                         │
└───────────────────────────┼────────────────────────────────┘
                            │
┌───────────────────────────┼────────────────────────────────┐
│                  Backend (Rust/FFmpeg)                     │
│         ┌─────────────────┴──────────────────┐             │
│         │     Decoder Pool (LRU Cache)       │             │
│         │  (VideoToolbox / D3D11VA / VAAPI)  │             │
│         └─────────────┬────────────────────┬─┘             │
│         ┌─────────────▼────────┐  ┌────────▼──────────┐    │
│         │  Frame Decoder       │  │  Export Pipeline  │    │
│         └──────────────────────┘  └───────────────────┘    │
└────────────────────────────────────────────────────────────┘

For performance benchmarks and technical deep-dives, see the Clypra Runtime Performance Architecture, Native Performance Contract, the Performance Telemetry Specification, and the Program Preview Performance Runbook.

Installation

Download pre-built binaries from Latest Releases.

  • macOS (Homebrew): brew install AIEraDev/tap/clypra or download Clypra-universal.dmg.
  • Windows: Download and run Clypra-x64.msi.
  • Linux: Download Clypra-x86_64.AppImage (chmod +x and run).

Development

Prerequisites

  • Node.js 18+ & npm
  • Rust 1.70+ (rustup)
  • FFmpeg 6.0+ with development headers

Quick Start

# Clone repository
git clone https://github.com/AIEraDev/clypra.git
cd clypra

# Install dependencies
npm install

# Setup environment variables
cp .env.example .env

# Run development mode
npm run tauri dev

Repository Structure

  • src/ — React 19 + TypeScript frontend (UI, timeline, canvas renderer, Zustand state).
  • src-tauri/ — Native Rust backend (FFmpeg decoder pool, hardware acceleration, Tauri IPC commands).

Scripts & Testing

npm test                 # Run frontend tests
cd src-tauri && cargo test # Run Rust backend tests
npx tsc --noEmit         # Type check
npm run format           # Format codebase

Contributing & License

  • Contributing: Contributions are welcome! Read CONTRIBUTING.md for guidelines and code standards.
  • License: Clypra is open source under the MIT License. FFmpeg dependencies are licensed under LGPL v2.1+.
  • Sponsorship: Help sustain Clypra by sponsoring on GitHub Sponsors or reading SPONSORS.md.

Frequently asked questions

Is Clypra free to use?

Clypra is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Clypra do?

A hardware-accelerated video editor built on Rust, Tauri v2, and React 19. Sub-10ms frame decoding, GPU-native rendering, and a frame-accurate timeline — all fr

What is Clypra written in?

Clypra is primarily written in TypeScript. Its source is publicly available at https://github.com/AIEraDev/Clypra, and it has 3,240 GitHub stars.