Cliprithm — Smart Silence Remover & AI-Ready Video Editor

Cliprithm is a desktop video editor that removes silence and creates clean jump cuts in seconds. Its built-in local MCP server lets AI agents—including Claude Desktop, VS Code, Devin, and other MCP clients—inspect and edit your projects. Add timeline notes (semantic ranges) to mark what happens in a segment, so AI can read them later as reference in video-creation workflows.

Features

Editing

• Smart Cut: Automatically detects and removes silent segments from video
• Time Warp: Speed up silent segments instead of cutting them
• Playback Speed: Global 0.5x – 4x speed with manual input
• Clip Editor: Trim, split, delete, and rearrange clips on a visual timeline
• Undo: Ctrl+Z to revert edits
• Project Persistence: Auto-save progress, resume editing anytime

AI & Automation

• MCP Server: Let AI agents inspect and edit your active video projects through a local MCP connection
• Timeline Notes (Semantic Ranges): Add labeled notes to timeline segments for human and AI context; agents can read and write them through MCP
• Captions Beta: Generate transcriptions (OpenRouter, Cerebras, Groq, Ollama, LM Studio)

Export & Rendering

• Export Presets: TikTok/Shorts, Instagram Reels, Custom (1080p/4K, 30/60fps)
• Render Optimization: Hardware-aware decode/encode, cached proxy previews, short playhead previews, and stream-copy cuts when compatible
• Incremental Auto-Preview & Export Size Estimates: Preview updates incrementally as you edit, with export size estimates before rendering (added in 1.8.0)

Distribution

• Auto Updates: Automatic update checking via GitHub Releases
• Store-Aware Updates: GitHub installs self-update, while AUR/Snap/Flatpak/Homebrew channels can switch to store-managed guidance
• Cross Platform: Linux, Windows, macOS
• i18n: English and Spanish

AI Integration (MCP)

Cliprithm's local MCP server is enabled by default and runs only while the app is open. Toggle it or change its port in Settings > MCP Server. It uses Streamable HTTP at http://127.0.0.1:<port>/mcp and binds to localhost only.

Settings displays a per-session bearer token and copyable setup JSON for Claude Desktop (using mcp-remote), VS Code, and Devin. Keep the token private; do not commit client configuration containing it. When no custom port is configured, the default is 47831.

For example, the VS Code configuration shape generated by Settings is:

{
  "servers": {
    "cliprithm": {
      "type": "http",
      "url": "http://127.0.0.1:47831/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_CLIPRITHM_MCP_TOKEN"
      }
    }
  }
}

Available tool groups include:

• Projects and media
• Selection and timeline editing
• Silence detection
• Preview, jobs, and export
• Semantic ranges
• History undo/redo

Tools use the cliprithm_ prefix. Composition mutations are revision-checked; deleting a saved project, overwriting an existing export, or leaving an unsaved project requires a short-lived confirmation token. See the MCP editor contract for the full contract.

Timeline Notes (Semantic Ranges)

Mark a segment on the dedicated semantic-range timeline track: drag to create a range, then resize its edges. Add a title, description, and tags to describe what happens in that segment. Notes are stored in the project and keep their timeline position when clips are moved, split, or trimmed. You can create them yourself or have an AI create them (createdBy: user | ai); AI agents can read and write them with the cliprithm_semantic_range_* tools.

Use these notes to:

• Help an agent choose promising moments to turn into Shorts
• Give an agent context for drafting titles, descriptions, or scripts
• Reuse annotated footage as reference when assembling new videos

Tech Stack

• Desktop Framework: Tauri v2
• Frontend: React 19 + TypeScript + Vite
• Styling: TailwindCSS v4
• State: Zustand
• Backend: Rust
• AI Integration: MCP server (Streamable HTTP) embedded in the Rust backend (rmcp)
• Database: SQLite (via tauri-plugin-sql)
• Video Processing: FFmpeg

Prerequisites

• Node.js >= 22
• pnpm >= 10
• Rust (stable)
• System dependencies for Tauri (see the official Tauri prerequisites guide for the most up-to-date steps):
  • Windows: Microsoft C++ Build Tools and WebView2 (usually pre-installed on Windows 10/11)
  • macOS: Xcode Command Line Tools (xcode-select --install)
  • Ubuntu/Debian: libwebkit2gtk-4.1-dev libgtk-3-dev librsvg2-dev patchelf
  • Arch/Manjaro: webkit2gtk-4.1 gtk3 librsvg
• FFmpeg:
  • Windows / macOS: No manual installation needed. pnpm install downloads FFmpeg and FFprobe for local Tauri builds, and official releases package both binaries inside the application.
  • Linux: Official packages include FFmpeg and FFprobe. Development builds use the system installation when available; no manual installation is required for official releases.

Setup

# Install dependencies
corepack enable
corepack prepare pnpm@10.33.0 --activate
pnpm install --frozen-lockfile

# Run in development mode
pnpm run tauri dev

# Build for production
pnpm run tauri build

# Remove generated build/debug artifacts
pnpm run clean

# Validate the Linux release bundle locally before publishing
pnpm run verify:linux-release

# Validate both AUR package variants locally
pnpm run verify:aur:source
pnpm run verify:aur:bin

On local Linux builds, pnpm run tauri build now auto-enables the AppImage fallback used by linuxdeploy, skips the problematic strip pass, and disables updater artifacts when no signing key is configured. That makes unsigned local builds work more reliably on distros like Arch/Manjaro.

Installing from Releases

Files ending in .sig and latest.json are not installers:

• .sig files are release/update signatures
• latest.json is used by the in-app updater for GitHub-distributed builds

Linux

Target system	Release file	What to do
Arch / Manjaro	AUR cliprithm	yay -S cliprithm
Arch / Manjaro	AUR cliprithm-bin	yay -S cliprithm-bin
Ubuntu / Debian	Cliprithm_<version>_amd64.deb	sudo apt install ./Cliprithm_<version>_amd64.deb
Fedora / RHEL	Cliprithm-<version>-1.x86_64.rpm	sudo dnf install ./Cliprithm-<version>-1.x86_64.rpm
openSUSE	Cliprithm-<version>-1.x86_64.rpm	sudo zypper install ./Cliprithm-<version>-1.x86_64.rpm
Generic Linux	Cliprithm_<version>_amd64.AppImage	portable fallback; see below

For the AppImage:

chmod +x Cliprithm_<version>_amd64.AppImage
./Cliprithm_<version>_amd64.AppImage

On Arch / Manjaro, if direct AppImage mounting fails, install the compatibility package once:

yay -S --needed fuse2

If the AppImage opens with a blank or white window on Arch / Manjaro, run it in one single line:

APPIMAGE_EXTRACT_AND_RUN=1 WEBKIT_DISABLE_DMABUF_RENDERING=1 WEBKIT_DISABLE_COMPOSITING_MODE=1 LIBGL_ALWAYS_SOFTWARE=1 ./Cliprithm_<version>_amd64.AppImage

For Arch-based distros, cliprithm-bin is the preferred package because it already wraps the AppImage in the recommended AUR launcher.

If cliprithm-bin fails with This doesn't look like a squashfs image, remove any stale locally built package and reinstall:

yay -Rnc cliprithm-bin || true
rm -rf ~/.cache/yay/cliprithm-bin
yay -S cliprithm-bin

That error means the AppImage payload was stripped while packaging, leaving only the small AppImage runtime instead of the full release artifact.

Windows

• Use Cliprithm_<version>_x64-setup.exe for the normal interactive installer
• Use Cliprithm_<version>_x64_en-US.msi for managed or silent MSI deployment

FFmpeg is bundled inside the installer — no separate FFmpeg installation is required.

If for any reason the app reports a missing FFmpeg (e.g. after a corrupt install), you can install it as a fallback using winget — no PATH configuration is needed:

winget install ffmpeg

Alternatively, download a pre-built Windows build from the official FFmpeg website or from gyan.dev and add the bin folder to your PATH manually. Reinstalling Cliprithm from a fresh download is usually simpler.

macOS

• Download the .dmg that matches your Mac CPU:
  • Apple Silicon: aarch64
  • Intel: x64
• Open the .dmg, drag Cliprithm.app into Applications, and start it from there

If a specific release tag does not include macOS assets, that tag was published without the macOS build job.

AUR Publishing Automation

Cliprithm now has tooling for two AUR variants:

• cliprithm → source-based package
• cliprithm-bin → binary package backed by the release AppImage

GitHub Actions now publishes both AUR package variants when the SSH key is configured and the target AUR repositories exist.

The local/publication tooling:

• generates PKGBUILD and .SRCINFO from the release version and tag
• points the package either to the tagged GitHub source tarball or to the release AppImage
• computes the required sha256 values automatically
• can be validated locally with makepkg before publishing

Required GitHub configuration:

• Secret: AUR_SSH_PRIVATE_KEY
• Optional repository variable: AUR_PACKAGE_REPO_SSH_URL

Default AUR repository URLs if the variable is not set:

ssh://aur@aur.archlinux.org/cliprithm.git
ssh://aur@aur.archlinux.org/cliprithm-bin.git

The workflow derives cliprithm-bin.git automatically from AUR_PACKAGE_REPO_SSH_URL, so you do not need a second repository variable for the binary package.

Recommended maintainer setup:

1. Create or use your AUR account
2. Generate a dedicated SSH keypair for AUR publishing
3. Add the public key to your AUR account
4. Save the private key in this repo as AUR_SSH_PRIVATE_KEY
5. Make sure that same key has write access to both AUR repos
6. Let the release workflow publish both packages on future releases

Local validation flow:

# Build the Linux artifacts that users will receive
pnpm run verify:linux-release

# Validate source AUR metadata and sources
pnpm run verify:aur:source

# Validate binary AUR metadata against the locally built AppImage
pnpm run verify:aur:bin

When updating only the AUR packaging for an already published app version, regenerate the AUR files with an incremented pkgrel and push both AUR repositories so users receive the fixed package metadata.

See distribution-playbooks/aur.md for the full strategy and the notes for cliprithm-bin.

Store Channels and Update Behavior

• GitHub installers / AppImage from Releases use the built-in Tauri updater.
• AUR / AUR bin are now prepared to run in store-managed mode, with the app pointing users back to AUR and checking the package version through the AUR RPC API.
• Snap / Flatpak / Homebrew now have repo scaffolding under packaging/ plus playbooks in distribution-playbooks/, and the app can check public store metadata before guiding the user back to that channel.
• For store-managed channels, the app is designed to avoid self-installing updates and instead guide the user back to the store/package manager that delivered the app:
  • Snap -> Snap Store API
  • Flatpak -> Flathub appstream API
  • Homebrew -> Homebrew Cask JSON API or a raw tap cask file when you override the build env

Packaging scaffolding added in this repo:

• packaging/flatpak/com.botom.cliprithm.yml
• packaging/snap/snapcraft.yaml
• packaging/homebrew/cliprithm.rb.template
• packaging/linux/ shared desktop/appstream metadata

Cleanup

When the project starts consuming too much disk space again, use:

pnpm run clean

That removes dist, src-tauri/gen, src-tauri/target, and Snapcraft build artifacts under packaging/snap/ (.snapcraft, parts, prime, stage, and generated .snap files).

If you also want to remove node_modules:

pnpm run clean:full

pnpm run clean:full also removes node_modules and .playwright-mcp.

Project Structure

cliprithm/
├── src/                       # React frontend
│   ├── components/
│   │   ├── layout/            # TopNavBar, SideNavBar, MainLayout
│   │   ├── import/            # EmptyState, MediaLibrary
│   │   ├── processing/        # ProcessingView
│   │   ├── editor/            # EditorView, SettingsPanel
│   │   ├── timeline/          # Timeline with clip visualization
│   │   ├── export/            # ExportModal with presets
│   │   ├── about/             # About & Sponsor page
│   │   └── ui/                # Button, Slider, Toggle, SpeedControl, Icon
│   ├── stores/                # Zustand stores
│   ├── services/              # DB, Tauri command wrappers
│   ├── hooks/                 # Auto-save, custom hooks
│   └── lib/                   # i18n, logger, utilities
├── src-tauri/                 # Rust backend
│   ├── src/commands/          # FFmpeg, library, media server, MCP
│   └── tauri.conf.json
├── packaging/                 # Flatpak, Snap, Homebrew, and shared Linux metadata
├── distribution-playbooks/    # Packaging and store deployment notes
├── .github/                   # CI/CD, issue templates
├── docs/                      # Specs, including the MCP contract
└── public/                    # Logo, static assets

Contributing

See CONTRIBUTING.md for development setup and guidelines.

License

MIT — Made with 💜 by Edwar Diaz