Repository navigation
Video Editor
Just finished a screen recording and need to chop off the awkward first three seconds? That's exactly what the Video Editor is for. It's a lightweight editing surface built right into the shell — preview, trim, crop, compress, save — so quick cleanups never require launching a full desktop video editor.
Under the hood, the interface is pure Quickshell with Qt Multimedia for playback, while FFmpeg does the actual processing.
- Finish a screen recording (Ctrl + Alt + R to start/stop fullscreen, or Super + Shift + R for a region) — a "Recording finished — edit it?" popup appears. Click Edit Video.
- Or open the editor any time with Super + Shift + V (or the Dashboard's Video Editor Quick Toggle) and drag any video file in.
- Trim — drag the two timeline handles; playback loops inside the kept range so you always preview the final cut.
- Crop — drag directly on the preview, or start from an aspect preset (16:9, 9:16, 4:3, 1:1).
- Compress — set the quality slider and watch the estimated output size.
- Click Save Copy (writes
<name>_edited_1.mp4next to the original) — or Save and Replace if you're sure. You can close the editor immediately; a notification reports when processing finishes. - Want the audio alone, or a GIF? Pick Audio (MP3) or GIF Animation as the export format and press Export & Render — a render screen shows progress and hands you the file when it's done.
From a keybind or the Dashboard — Super + Shift + V or the dedicated Video Editor Quick Toggle opens the editor empty. Load a video by dragging it anywhere onto the window (the whole empty editor is a drop target) or via Browse Files (filters MP4, MKV, WebM, AVI, MOV). This makes the editor a handy general-purpose video utility, not just a recording companion. Dropping another video onto an editor that already has one loads it in place — no need to close and reopen between clips.
After a recording — when a screen recording finishes, the recorder hands the file path back to Quickshell (via the launchVideoEditor IPC handler), and a small "Recording finished — edit it?" popup appears on the focused monitor, respecting the bar and notification positioning. One click on Edit Video opens the full editor with the recording loaded. Ignore it and it dismisses itself after ~8 seconds (paused while you hover); opening a major shell surface like the Dashboard also politely dismisses it.
One deliberate detail: the video is not loaded while only the popup is visible — the source is assigned only when the full editor opens. No recorded audio suddenly looping in the background while you're still deciding.
Playback starts automatically and loops inside the current trim range, so you're always previewing exactly what will be exported. Space (or the button) toggles play/pause; Esc closes the editor, stopping playback completely.
Two handles on the timeline set the start and end. Dragging a handle seeks to that boundary live, and playback bounces back to the start of the range when it hits the end. Clicking elsewhere on the timeline seeks — the playhead is independent from the trim handles, so the same strip works as both trim control and seek bar.
Cropping happens visually on the preview: the discarded area darkens, the kept area stays bright. Move it, resize it, reset it, or start from an aspect preset — Free, 16:9 (desktop/YouTube), 9:16 (Shorts/Reels), 4:3, 1:1 — which centers the crop while keeping as much of the frame as possible, and remains adjustable afterward.
The crop you see is in UI coordinates; before encoding, it's converted proportionally back into the native video resolution (and snapped to even dimensions for encoder compatibility). What you crop is what FFmpeg crops — at real pixels.
The preview's playback speed can be cycled with S (or the speed button), and the editor shows the clip's metadata — duration, resolution, original size and the audio track — beside the controls.
A quality percentage from 10% to 100%: at 100% the editor encodes at its best quality (CRF 18), and lower values progressively raise the CRF for smaller files. The editor shows the current file size next to an estimated output size — and the estimate is smarter than simple math: the backend probes the input and encodes short representative sample segments with the actual export profile to predict the result. Still treat it as an estimate; real output depends on content, motion, and what survives the trim.
The export format row offers Video (MP4), Audio (MP3) and GIF Animation:
- Audio (MP3) extracts the trimmed range's sound track.
- GIF Animation renders a high-quality animated GIF of the trimmed and cropped range, with its own controls: FPS, an output resolution (keep the source resolution or scale down — the resulting width × height is shown), a dither / encoder choice and a compression quality slider with an estimated size.
Both go through Export & Render, a dedicated render screen: what is being rendered (Rendering Video (MP4)…, Extracting Audio (MP3)…, Generating GIF Animation…), elapsed and total time, and on completion Open Video / Audio / GIF, Open Folder, Copy Path and Back to Editor. Failures are reported on the same screen.
-
Save Copy — keeps the original untouched and writes the edit next to it as
<name>_edited_1.mp4(incrementing the suffix until a free name is found). Perfect for experimenting. - Save and Replace — overwrites the original, but safely: FFmpeg writes to a temporary output first, and only a successful result is moved over the source. A crash mid-encode can never eat your recording.
Processing runs outside the editor window, so you can close the editor immediately — desktop notifications (Editing Video…, Video Edited, Video Saved, Video Edit Failed) report progress and completion. On failure, the notification points at the processing log in /tmp/video_edit.log.
The editor is the natural endpoint of the shell's recording pipeline: both supported backends — wf-recorder and OBS Studio — hand their finished files straight into the edit prompt, and region recordings started from the Region Selector arrive the same way. The recording system itself (backends, hardware encoders, region + audio capture, pause/resume, OBS WebSocket control) is documented in Screen Capture & Recording.
The editor derives its surfaces, containers, borders, typography and rounding from the shared Material 3 appearance system, and respects your transparency settings — it feels like part of the shell, not a bolted-on external app.
Editing choices (trim, crop, compression) are per-video, inside the editor itself. Recording-related options — record path, backend selection, notifications, GPU acceleration, codec, bitrate, frame rate — live in Settings → Screenshots & Recording.
| Tool | Used for |
|---|---|
| Qt Multimedia | Preview and playback |
FFmpeg + ffprobe
|
Crop, trim, encoding, size estimation |
| Python 3 | The processing backend (scripts/videos/compress_video.py) |
kdialog / zenity
|
The file picker |
| wf-recorder / OBS Studio | The recording backends feeding the editor (optional — either one suffices) |
| File | Role |
|---|---|
modules/ii/videoEditor/VideoEditor.qml |
The full editing window: loading, playback and speed, drag-and-drop, timeline, trim handles, crop UI, presets, compression, export format and GIF options, save actions |
modules/ii/videoEditor/VideoEditorRenderPage.qml |
The render screen: progress for MP4 / MP3 / GIF exports, open / copy-path / back actions, error reporting |
modules/ii/videoEditor/VideoEditorPopup.qml + VideoEditorPopupContent.qml
|
The lightweight post-recording prompt: monitor placement, bar-aware margins, hover-aware timeout, popup→editor transition |
GlobalStates.qml |
Transient state (videoEditorPopupOpen, videoEditorOpen, videoEditorPath), the launchVideoEditor IPC handler and the videoEditorToggle global shortcut behind Super + Shift + V
|
scripts/videos/compress_video.py |
The FFmpeg backend: ffprobe probing, coordinate conversion, CRF mapping, sample-based size estimation, safe replacement, notifications, logging |
scripts/videos/record.sh + obs_control.py
|
The recording side — see [[Screen Capture & Recording |