Trim, stitch, and transition between video clips using a UI-driven ffmpeg pipeline. Built to turn raw CogVideoX and Wan2.2 generation outputs into finished, shareable videos — entirely on your own machine.
A timeline scrubber lets you set in/out points on each clip without entering timecodes manually. Drag the handles to your desired cut points, preview the trimmed segment, and lock it in. The UI generates the corresponding ffmpeg -ss and -to arguments, so there's no command-line knowledge required to achieve frame-accurate cuts.
Drag clips into a sequence, set their order, and the editor produces a single concatenated output via ffmpeg's concat demuxer. Each clip is normalised to a common resolution, frame rate, and codec before joining so the output plays without jank. You can stitch raw generation outputs from multiple sessions into a coherent narrative or demo reel.
Apply crossfade, cut, wipe, or dissolve transitions between clips. The editor calculates the ffmpeg xfade filter parameters automatically based on your chosen transition type and duration. Transitions are previewed before rendering, and the final render runs as a background Celery job so you can continue working while the export processes.
The video editor surfaces clips directly from the video generation output gallery. Select a generation job, browse its outputs, and import specific clips into the editor in one click without manually navigating the file system. Metadata from the generation job — prompt, model, resolution, seed — travels with the clip so you always know what produced each segment.
AI video generation produces raw clips that almost always need editing before they're shareable. CogVideoX outputs are typically 5–10 second segments at a fixed resolution; Wan2.2 outputs have similar characteristics. A finished video requires selecting the best takes, trimming dead frames from clip ends, stitching segments into a coherent sequence, and adding transitions that give the edit visual flow. The Guaardvark Video Editor handles all of these steps through a web UI backed by ffmpeg, the same video processing dependency already required by the audio pipeline.
The editor treats ffmpeg as its rendering engine rather than a general-purpose command-line tool. When you set an in-point on a clip, the UI translates your scrubber position into an ffmpeg -ss flag and issues the cut command as a Celery task. When you add a crossfade between two clips, the UI calculates the xfade filter graph. When you click Export, the editor assembles the full ffmpeg command from your edit decisions, submits it as a Celery job, and streams progress back to the UI via Socket.IO. You never need to touch the command line, but the underlying commands are logged so advanced users can inspect or replay them.
The Content Library integration means generated video clips are always one click away from the editor. Rather than downloading clips to your desktop and re-uploading them to an editing tool, you work directly against the data/outputs/ directory where generation results already live. Finished edit exports are registered as new entries in the Content Library alongside their source clips, maintaining a clear provenance trail from prompt to final video.
ffmpeg integration. ffmpeg is a required system dependency validated by start.sh during startup. The video editing service wraps ffmpeg commands via Python's subprocess module, with each operation represented as a structured command object that can be logged, retried, and cancelled. Trim operations use stream copy mode (-c copy) for instant cuts with no re-encode, switching to re-encode only when transitions require frame blending. The concat demuxer handles multi-clip stitching with a generated playlist file; when resolution or frame-rate normalisation is needed, the video is scaled via the libx264 encoder before concatenation. Output files use MP4 with H.264 video and AAC audio for maximum compatibility.
Background rendering and progress. All rendering operations run as Celery tasks dispatched by unified_task_executor.py. Job progress — frames rendered, percentage complete, estimated time remaining — is emitted over Socket.IO using the unified_progress_system.py framework. The useJobSocket React hook subscribes the UI to these events, keeping the timeline and export button in sync with the render state without polling. Rendered outputs land in data/outputs/ and are immediately available in the Content Library and Files browser.
# Trim a clip via API (millisecond in/out points)
curl -X POST http://localhost:5000/api/generation/video/trim -H "Content-Type: application/json" -d '{"file_id": "vid_abc123", "start_ms": 500, "end_ms": 7200}'
# Stitch clips into a sequence
curl -X POST http://localhost:5000/api/generation/video/stitch -H "Content-Type: application/json" -d '{"clips": ["vid_001", "vid_002", "vid_003"], "transition": "crossfade", "transition_duration_ms": 500}'Generate five to ten short clips showing different aspects of a product using CogVideoX. Import them into the Video Editor, trim the weak frames from each clip's start and end, sequence them in narrative order, add crossfades, then export. Feed the output to Video Text Overlay for a lower-third title and captions. The entire post-production workflow runs locally from a single platform.
Generate raw clips at the aspect ratio required by your target platform, trim them to the platform's clip length limits (60 seconds for Instagram Reels, 3 minutes for YouTube Shorts), stitch multiple takes if needed, and export. Pair with Audio Foundry to add a narration track and with Video Text Overlay to add captions for silent-autoplay reach. The entire pipeline is local and unmetered.
Use the Video Editor to trim a large collection of raw video samples to the precise segment length and quality threshold required for fine-tuning data. Consistent in/out point trimming across hundreds of clips is tedious manually but straightforward as a batch API operation. Stitching curated clips into organised sequences creates structured training sets with clear semantic transitions.
Browser-based video editors like Kapwing or Descript process your clips on their servers, impose file size limits, watermark free-tier exports, and charge per minute of exported video on paid plans. Guaardvark's Video Editor runs ffmpeg on your own hardware: no file size limits, no watermarks, no per-export fees, and no video leaving your network. For creators working with proprietary footage, unreleased products, or simply large volumes of clips, local processing eliminates both the cost and the privacy exposure of cloud tools. The tight integration with Guaardvark's video generation, audio, and text-overlay features means you can complete the full production pipeline without leaving the platform.
Any format that ffmpeg can decode is accepted as input: MP4, MOV, MKV, WebM, AVI, and more. CogVideoX outputs are MP4; Wan2.2 outputs are also typically MP4. The editor normalises resolution and frame rate automatically when stitching clips from different sources, so you don't need all clips to share the same encoding settings before import.
Trim operations use ffmpeg's stream copy mode (-c copy) when no transition is applied, which is lossless and nearly instantaneous. When a crossfade or dissolve transition is applied at a cut point, a small re-encode is performed only for the frames involved in the transition, minimising quality loss while enabling smooth blending.
Yes, via the Audio Foundry integration. Generate or upload an audio file (narration, music, sound effects), then attach it to a video sequence in the editor. The mixing step uses ffmpeg's audio filter chain to set relative volume levels and synchronise timing. For captions derived from the audio, connect to Video Text Overlay.
Stream-copy exports (trim only, no transitions) are nearly instant even for long clips because no re-encoding occurs. Exports with transitions or audio mixing require re-encoding and take approximately 1–3× real time on a modern CPU, or 0.1–0.5× real time with GPU-accelerated ffmpeg. Export jobs run in the background so you can continue using the platform while they process.
All exports are saved to data/outputs/ and registered in the Content Library with metadata linking to the source clips and edit parameters. You can download them from the Content Library or access them via llx files list in the terminal. Exports are also visible in the job history on the Dashboard with their creation time and file size.