Auto-transcribe with Whisper.cpp, style your captions, and burn them into the video via ffmpeg drawtext. Add lower-thirds and title cards for silent-autoplay social content and accessibility compliance — all offline.
Drop a video file and Whisper.cpp transcribes the audio track to a timestamped subtitle file. The same Whisper.cpp binary used throughout the audio pipeline handles the transcription, so you get consistent quality with no additional configuration. Transcripts are editable before burning so you can fix misheard terms or adjust timing before committing.
Configure font, size, colour, stroke, background box, position (bottom-third is default), and maximum line length. Styles are stored as named presets so you can maintain a consistent look across a series without re-entering settings each time. The preview renders a sample frame with your style applied so you can iterate without running a full export.
Beyond captions, add name-and-title lower-thirds at specific timestamps, opening title cards, and end cards. Each overlay element is defined by a time range, text content, style preset, and screen position. The editor assembles the ffmpeg filter graph that applies all overlays in a single encode pass, so you don't accumulate re-encode quality loss from multiple passes.
Choose between burned-in (hardcoded) captions that display on every player without any viewer action, and sidecar SRT or VTT files that players can toggle on or off. For social-media autoplay — where 85% of viewers watch without sound — hardcoded captions are the default. For YouTube and accessibility-focused distribution, the sidecar SRT export is provided alongside the video.
Video Text Overlay exists because two audiences demand text on video: people watching on mute (the majority of social media autoplay views) and people using screen readers or who are deaf or hard of hearing. Providing captions is both a reach multiplier and an accessibility requirement for many distribution contexts. The standard approach requires a separate transcription service, a separate caption editor, and a separate video encoding step. Guaardvark consolidates all three into a single workflow using tools already present in the platform.
The transcription step calls Whisper.cpp on the video's audio track. The same binary used for voice chat and Audio Foundry transcription handles the video audio, producing a timestamped transcript in SRT format. The SRT file appears in the caption editor where you can correct any transcription errors, split long lines, and adjust timing where Whisper's silence detection was slightly off. Once the caption data is clean, you choose a style preset and proceed to the overlay step.
The overlay engine translates your style settings into an ffmpeg filter graph using the drawtext filter. For multi-line captions with a background box, the filter graph chains a drawbox filter with the drawtext filter, both keyed to the subtitle timing. For lower-thirds and title cards, additional drawtext and fade filters are added to the chain. The entire graph runs in a single encode pass, producing a finished video file in data/outputs/ without intermediate files. The Celery job system handles long encodes in the background with real-time progress reporting, so the UI remains responsive during a multi-minute export.
Transcription pipeline. Audio is extracted from the input video using ffmpeg (-vn -acodec pcm_s16le), normalised to 16 kHz mono WAV for Whisper.cpp, and passed to the Whisper CLI binary at backend/tools/voice/whisper.cpp/build/bin/whisper-cli. The --output-srt flag produces a timestamped SRT file that is returned to the frontend caption editor. Model selection (tiny through large) is governed by the same setting used for voice chat transcription, defaulting to the base model for speed. The SRT is stored in the project's file store and can be downloaded independently of the captioned video.
ffmpeg filter graph construction. The overlay service builds the ffmpeg filter graph programmatically from the overlay specification. Caption overlays use subtitles filter or drawtext depending on whether word-level timing is required. Lower-thirds and title cards use drawtext with enable='between(t,START,END)' expressions. Background boxes use drawbox chained before the corresponding drawtext. All filters are combined into a single -vf chain, ensuring a single-pass encode. The resulting ffmpeg command is logged to the job record for transparency and can be inspected or re-run manually by advanced users.
# Auto-transcribe + burn captions in one step
curl -X POST http://localhost:5000/api/generation/video/caption -H "Content-Type: application/json" -d '{
"file_id": "vid_abc123",
"transcribe": true,
"style_preset": "social-white-bold",
"hardcode": true,
"export_srt": true
}'
# Add a lower-third at a specific timestamp
curl -X POST http://localhost:5000/api/generation/video/overlay -H "Content-Type: application/json" -d '{
"file_id": "vid_abc123",
"overlays": [
{"type": "lower-third", "text": "Dean Albenze
Founder, Guaardvark",
"start_s": 2.0, "end_s": 6.0, "style_preset": "lower-third-dark"}
]
}'85% of social video plays without sound. Hardcoded captions are the difference between a scroll-stopping clip and one viewers skip because they can't tell what it's about in the first two seconds. Generate a video clip, run auto-transcription, review the SRT for accuracy, apply a bold white caption style, and export. The entire workflow takes under five minutes and produces a caption-native clip ready for any platform.
Use lower-thirds to identify speakers or label diagram elements. Add a title card at the opening with your brand name, a chapter title at each content transition, and an end card with a call to action. All overlay elements are defined in the overlay specification and applied in a single encode pass. The result is a polished, branded video that looks like it was edited in a professional NLE — produced entirely from Guaardvark.
Export both a hardcoded-caption video (for social distribution) and a clean video plus SRT sidecar file (for YouTube and other platforms that support selectable captions). The sidecar SRT is stored in the project file system and can be submitted to YouTube's subtitle upload, used for website embedded video accessibility, or ingested into the Documents surface for searchable transcript archiving.
Cloud captioning tools like Rev, Kapwing, or Descript upload your video to their servers to run transcription, charge per minute of audio, and require an internet connection for every caption job. Guaardvark runs Whisper.cpp and ffmpeg entirely on your hardware: the cost is zero beyond electricity, there are no upload delays for large files, and no video content leaves your machine. For creators handling unreleased footage, interview recordings, or client work under NDA, the privacy argument is decisive. The tight integration with the Video Editor and Content Library means you don't need to break out of Guaardvark to caption, style, and export — the whole workflow is one surface.
Yes. After Whisper.cpp produces the SRT file, it opens in the caption editor where you can correct text, adjust start/end times by dragging handles, split long lines that would overflow the caption area, and merge short lines that appear too briefly. Only after you confirm the SRT do you proceed to the style and export step.
Any font installed on the server system is available to ffmpeg's drawtext filter. Guaardvark ships with a set of common web-safe and display fonts. You can add additional fonts by installing them in the system font directory and restarting the backend. The caption style preset stores the font name, so presets are portable across machines that have the same fonts installed.
Yes — burning text into video frames always requires re-encoding the video stream. Audio is usually copied without re-encoding (-c:a copy) unless the audio needs remixing. The quality loss is minimal with a high-quality H.264 encode (CRF 18–23 range). Stream-copy is not possible for burned-in overlays because the overlay is drawn on the decoded frames before re-encoding.
Yes. The Video Text Overlay feature treats any video file in data/outputs/ as a valid input, regardless of how it was produced. You can chain the workflow: generate → trim → stitch → caption → final export. Each step reads from and writes to the output store, and each output is registered in the Content Library with its provenance chain intact.
No hard limit. Long video files take longer to transcribe (Whisper.cpp processes faster-than-real-time on most hardware for the base and small models) and longer to encode the captioned output. Both steps run as Celery background tasks and report progress over Socket.IO, so you can start a 30-minute video caption job and come back to the finished file without keeping the browser tab open.