Compress, trim & enhance video. No upload. No watermark. No cap.

This is a free online video compressor and edit workbench that processes MP4, MOV, MKV, WebM, AVI, FLV and MPEG-TS entirely in your browser. It is built for the situations cloud tools handle badly: sending a large recording over email or chat, fitting footage under an upload cap, prepping screen recordings and gameplay for the web, merging multiple takes, and working with footage you simply cannot put on someone else's server. Unlike Clideo it adds no watermark, unlike Kapwing and Veed it imposes no file-size or duration cap, and unlike FreeConvert it never uploads the file in the first place — so compression starts immediately, regardless of file size.

The same workbench also records, edits, merges and enhances video without leaving the tab: frame-accurate trim, free crop, playback-speed changes, rotation and flips, color tuning with six looks, text and logo overlays, mark-and-remove watermarks, portrait background blur or replacement, stabilizer, audio denoise, and AI super-resolution up to 4K. Every effect runs on your device through WebCodecs, WebAssembly or WebGPU; the model name, research lab and a clickable model card are shown in the Enhance panel before you start — and five of the effects (watermark inpainting, dynamic bitrate, stabilizer, WSOLA pitch-preserving audio, and WebCodecs encode path) are classical algorithms, not neural networks.

How it works

There is no server-side ffmpeg and no ffmpeg.wasm download. A small WebAssembly build of ffmpeg's libavformat demuxer (web-demuxer) runs in a worker inside your tab and splits the container into encoded video and audio packets. Your browser's native WebCodecs decoders unpack the frames, and its hardware-accelerated VideoEncoder re-encodes them at the new bitrate, resolution and frame rate, while AudioDecoder/AudioEncoder handle the sound track (with linear resampling and downmixing when needed). A tiny JavaScript muxer — mp4-muxer or webm-muxer — writes the finished container, with fast-start (moov atom first) so playback begins instantly. The engine and muxer libraries are fetched once from a pinned CDN URL on first use and cached by the browser; your video is never part of any request.

Edit: speed, transform, color, overlays — WYSIWYG

Speed changes use WSOLA (Wavelet-Synchronous Overlap-Add), a classical DSP algorithm that stretches or compresses the audio timeline while preserving pitch — no chipmunk at 0.5× or bass boost at 2×. Speed is applied live to the preview video's playback rate and folded into the encode pipeline at export.

Transform — 90° CW rotation (four steps: 0°/90°/180°/270°), horizontal flip, vertical flip — is rendered live via CSS transform on the preview and burned into the output at encode time. Phone-encoded video is re-oriented correctly before any transform is applied.

Color tuning — brightness, contrast, saturation and warmth sliders (−1 to +1) plus six color looks (vivid/warm/cool/mono/sepia) — is rendered live via CSS filter and folded into the encode pipeline. The looks map to perceptual filter chains rather than model inference, so adding them has negligible export cost.

Overlays — text with size, boldness, font stack (system/serif/mono/rounded/condensed), color and optional pill background; logo images uploaded locally and converted to ImageBitmap — are positioned as normalized [0,1] center coordinates relative to the frame. Drag on the preview to move, Shift+drop snaps to a 9-grid, arrow keys nudge 1 px and Shift+arrow nudges 10 px, and Delete removes an overlay. Each overlay is composited onto the decoded frames before encode — there is no intermediate PNG, so export stays fast.

Enhance: background, watermark, stabilizer, upscale

Background treatments use Google's MediaPipe Selfie Segmentation (ONNX build under 0.3 MB) to produce a foreground mask, then apply one of four modes: off (original), blur (adjustable strength), color (solid fill over the masked background), or image (custom uploaded image composited behind the subject). Because the mask is computed per frame it handles movement, but heavy motion or very dark scenes can degrade the edge quality — the honest ETA and detected mask stability are shown before export.

Watermark removal is not a neural network: you paint the static logo or subtitle band, and a classical content-aware inpainting algorithm fills each frame from surrounding pixels with temporal propagation so the repair does not flicker. The watermark tool is intentionally disabled in the Merge builder (cross-clip watermarks don't line up).

Stabilizer is a Lucas-Kanade pyramid global motion estimator — classical computer vision, not a neural network — that tracks the dominant motion in every frame and counter-shifts it. It has one strength slider (1–100, default 70) and adds roughly 0.06 seconds of export time per second of source at default strength. The tool honestly labels itself 'not a neural network' in the UI and model disclosure.

Super-resolution uses Real-ESRGAN General x4v3 (Tencent ARC Lab) at ×2, ×4, up-to-1080p or up-to-4K targets. Because it reconstructs every frame individually — 1,800 neural passes per minute of 30 fps — it runs on WebGPU when available and falls back to WebAssembly; the control shows a live frame count and honest ETA range. Sources already at or above the target resolution are left untouched. The Enhance panel always lists the exact model, vendor and model card for every capability, including the five that contain no model: watermark inpainting, dynamic bitrate (scene heuristic), stabilizer (Lucas-Kanade), WSOLA audio stretch, and WebCodecs encode path.

Audio: keep, volume, fade, denoise

Free plans can disable the track entirely; Pro additionally removes it as a normal export option. When kept, the track is re-encoded to AAC in MP4 or Opus in WebM at the same bitrate as the original (never up-bitrate). Volume is a plain gain scalar that runs before fade in/out curves. The fade sliders (0–5 seconds each) set linear attack/release on the gain envelope and are folded into the encode pipeline.

Audio denoise uses the two-stage DTLN network (Breizhn — Westhausen & Meyer, Interspeech 2020) at 16 kHz to suppress steady background noise. It is skipped automatically when the clip has no audio or keep-audio is off, and its strength slider (1–5) maps to how much residual noise to accept. The DTLN model file (~1 MB) downloads once on first use and caches.

Record: WebRTC capture

The Record tab opens a WebRTC getDisplayMedia() dialog — pick a tab, a window, or the full screen, plus system audio and your microphone. Take as many takes as you want; each clip stays local, you preview it live in the preview area, and the active take is the current working video. Nothing is uploaded during recording, and there is no duration cap — the only limit is disk space on your device. After stopping, the recording enters the Compress/Analyze/Ready pipeline exactly like a dropped file.

Merge: multi-clip timeline

The Merge builder in the idle stage adds 2–5 clips (Pro: 25) via file picker or drag-and-drop. Each clip is probed locally via getPipeline().probe() to get dimensions, fps and duration before being added. Trim each clip independently (startSec and endSec, with endSec=0 meaning 'to the end of the clip'), reorder via drag-or-up/down-buttons, and remove any clip. Merge does not apply cross-clip crop or watermark removal — dimensions and content can legitimately differ per clip, and watermarks in different positions would inpaint incorrectly.

Settings chosen in the Edit/Enhance/Audio/Export tabs apply uniformly to every clip in the merged timeline — meaning speed changes, background treatments, stabilizer, upscale and overlays all operate over the concatenated output. Keep-audio preserves every track and concatenates them; drop-audio mutes everything. The merge itself runs in the worker via mergeVideos(segments, settings), which resamples audio track boundaries across clips so transitions are seamless.

Merge imposes its own gate: Free merges up to 5 clips, Pro up to 25. AI effects count the total merged duration toward the AI allowance — 60 seconds on Free, unlimited on Pro — because cross-clip AI pipelines cannot run independently on each segment. Per-clip file size, resolution and duration each must meet the standard source limits (1 GB on Free, 4 GB on Pro; no single dimension over 4K; each clip ≤ 30 minutes).

Export: codecs, GIF, frames, audio-only

Four export kinds are offered, selectable in the Export tab. Video produces H.264 MP4 for universal playback, AV1 MP4/WebM for the smallest files, or VP9 WebM for web-native video — subject to what your browser can encode. GIF produces a shareable animation (up to 30 fps / 720 px on Free, 30 fps / 1080 px on Pro) from the working clip's trimmed selection, re-quantized to a 256-color palette. Frames produces numbered PNG files at the chosen fps. Audio re-encodes to M4A (AAC), MP3 or WAV — useful for podcast clipping or sampling.

Quality mode maps a 1–100 slider to a bits-per-pixel-per-frame budget scaled by each codec's efficiency, while target-size mode works backwards from your megabyte goal and the clip's duration to derive a video bitrate, reserving room for audio and container overhead. Resolution caps (2160p down to 480p, applied to the long edge so portrait video is handled correctly), frame-rate caps (30/24 fps), and a keep-audio toggle provide the big structural levers. The estimated output size updates live before you start, and warns when a source is already so efficient that the chosen settings may not shrink it.

Plans and AI limits

Compression, trim, crop, merge up to 5 clips, record, GIF export up to 720 px, frame export, audio-only export and batch processing all work without an account and never carry a watermark. The Free plan applies two boundaries only to the neural Enhance effects and to merge length: the processed selection may be at most 60 seconds long and the effect's output may not exceed 1080 pixels on the long edge — with ×4 super-resolution that means sources up to about 270p. Free merges up to 5 clips. Free batches process up to 10 videos and individual files up to 1 GB.

Pro removes the AI duration cap, allows Enhance output up to 4K (4096 pixels on the long edge), merges up to 25 clips, GIF up to 1080 px, frames up to 4K, audio-only export, files up to 4 GB, and batches of 100 videos. If you upgrade in another tab, the workbench re-checks the plan on window focus without a page reload. The limits live in a single configuration table in lib/perf-limits.ts, so the numbers shown in the tool, the upgrade prompts, and this guide cannot drift apart.

Limits & requirements

The tool needs the WebCodecs API: current desktop Chrome, Edge, Arc and Opera support every offered codec, and Safari supports it from version 16.4 (with a smaller codec set). Decoding the source also depends on the platform: H.264, VP9 and AV1 are broadly supported, while HEVC/H.265 only decodes where the operating system licenses it — recent macOS/iOS Safari and HEVC-capable Chrome builds. Whatever the input, output is always re-encoded to H.264, VP9 or AV1 for compatibility. AI effects additionally need WebGPU for full speed but all include a WebAssembly fallback. Re-encoding is lossy by nature, so keep an original if you may need another export later. Encode speed (shown live as a multiple of real-time) and memory use scale with source resolution and duration — 4K sources at 60 fps need ~2 GB of RAM per encoder instance.

Privacy

The video is read from your local disk by code running inside the browser tab and never leaves the device. There is no upload progress because there is no upload: the only network requests are one-time static downloads of the demuxer engine, muxer libraries and — only when an AI effect is enabled — its open-source model files from a public CDN, cached afterwards for offline reuse. Audio from the system mic during recording is captured via WebRTC getDisplayMedia() inside the tab and never leaves the device either. Nothing is logged, stored, analysed, or watermarked, and no account exists.