We put HyperFrames graphics over real footage: a lower third and a title card, rendered with alpha
Motion graphics for footage you already have: two HyperFrames compositions rendered as transparent video, placed on the clip with FFmpeg. We ran it on three 60-second clips of Tears of Steel, checked the text fit, the picture around the graphics and the legibility over the footage.
Tested by us on Nov 7, 2026, on the clips and machine listed below. Every number on this page was measured in that run.
The result
It works: two HyperFrames compositions rendered with a transparent background lay cleanly over real footage. A whole run (render the lower third, render the title card, overlay both and encode) took a median of 2.9, 3.3 and 3.2 minutes for the three 60-second clips on a CPU-only laptop, with peak memory of 1.3 GB or less. Each render of a 5-second graphic took a median of 30 seconds for the lower third and 29 for the title card.
Around the graphics the picture stayed clean: at most 0.0004 percent of the pixels outside the graphics boxes differed from a plain encode of the same clip while a graphic was settled, and at most 0.0004 percent differed at the four times with no graphic. Both graphics fit the frame at the text we gave them (left and right margins of 148 and 192 px for the lower third, 158 and 358 px for the title).
What it made




Footage: Tears of Steel, (c) Blender Foundation, mango.blender.org, CC-BY 3.0. These are files we made from it; they are shown under the same licence terms.
Frames from the first clip's composite: the title card, the lower third, and a frame between them with no graphic. The fourth frame is the lower third with a longer name (the text-fit check).
What failed or surprised us
- A longer name broke the lower third. With the 26-character name we used (Alexandria Montgomery-Ames) the lower third ended 192 px from the right edge of the frame. We rendered it once more with a 34-character name (Alexandria Montgomery-Featherstone): the text ran to the right edge of the frame (right margin 0 px) and was cut off. The composition has no fit logic, so a long name has to be shortened or the type size reduced before the render.
- The same title is easy to read on one clip and hard on another. White text with no card behind it had a contrast ratio against the average brightness of the picture behind the title of 1.8:1 on tos_a, 8.3:1 on tos_b and 4.7:1 on tos_c, and against the brightest tenth of that area 1.1:1, 3.4:1 and 2.4:1. On tos_a the title sits over a bright sky and part of it washes out in the frames we looked at. Text on footage needs a backing card or a darkening layer unless you know the shot.
- The browser was not the slow part. Each 5-second render took about 30 seconds. Overlaying the two transparent files and encoding took 115, 137 and 128 seconds of the 174, 199 and 191 second runs, because FFmpeg decodes ProRes 4444 with alpha and encodes 60 seconds of 1080p.
- Transparent files are big. The two 5-second ProRes 4444 files weighed 77 MB together. For an overlay you will reuse across many clips that is fine; for one clip, rendering the graphics onto the picture would avoid the files.
What we tested and how
- Tool: hyperframes-overlay version HyperFrames 0.8.10, FFmpeg 8.1.2, Apache-2.0 (HyperFrames), GSAP standard licence, LGPL/GPL (FFmpeg build).
- Settings compared: {"steps":"kicker-name lower third and calm title card written with exact text, HyperFrames transparent render (ProRes 4444, 1920x1080, 24 fps, 5 s each), FFmpeg overlay at 1 s and 7 s, x264 encode"}.
- Input clips: Tears of Steel, (CC) Blender Foundation, mango.blender.org, CC-BY 3.0. 60 s excerpts re-encoded to H.264 720p.
tos_a: 60 s starting at 20 s of the film, SHA-256945262dcbe106f1e...tos_b: 60 s starting at 180 s of the film, SHA-2564097773b615cddfa...tos_c: 60 s starting at 360 s of the film, SHA-2563d3a8cd015310349...
- Machine: AMD Ryzen 7 7735U (8 cores, 16 threads), integrated Radeon 680M, not used (CPU-only runs), 31.2 GB RAM, Windows 11 10.0.26300. The laptop was shared with other work, so timings are what a busy machine gives, not a clean benchmark.
- Runs: one cold run, then three timed runs per clip and setting. Run on 2026-11-07.
The job: add designed motion to footage you already have. We used two compositions from our effects pages: the kicker and name lower third (name "Alexandria Montgomery-Ames", role "Director of Platform Reliability and Developer Experience") and the calm title card (headline "Three things to check before you publish a video"). The script writes that text into each composition, renders each with HyperFrames 0.8.10 as a ProRes 4444 file with alpha (1920x1080, 24 fps, 5 seconds), then FFmpeg places the title at 1 second and the lower third at 7 seconds and encodes.
We ran the script as one process tree: one cold run and three timed runs per clip. We then checked the last run: the box each graphic occupies and its margins in the transparent renders; the composite against a plain encode of the same clip with the same filters; the average brightness behind each graphic; and, once, the lower third with a longer name to see where it breaks.
Measurements by clip
The whole job, per clip (two transparent renders and one composite)
| Clip | Cold run (s) | Timed runs (s) | Median run (s) | Peak memory (MB) | Output | File size (MB) | Transparent files (MB) | SHA-256 of the output (first 16) |
|---|---|---|---|---|---|---|---|---|
| tos_a | 183.2 | 173.6, 173.1, 179.7 | 173.6 | 1353 | h264 yuv420p 1920x1080 24/1 | 33.5 | 77 | 1aaef87323abf2a6 |
| tos_b | 194.5 | 190.6, 198.5, 203.3 | 198.5 | 1375 | h264 yuv420p 1920x1080 24/1 | 45.3 | 77 | d70c6ef2f042c362 |
| tos_c | 192.3 | 186, 191.9, 190.5 | 190.5 | 1359 | h264 yuv420p 1920x1080 24/1 | 33.7 | 77 | 4401f3bed5add7e1 |
Where the time went (median of the three timed runs, seconds)
| Clip | 1. Render the lower third | 2. Render the title card | 3. Overlay and encode | CPU load just before the four runs (%) |
|---|---|---|---|---|
| tos_a | 29 | 28.3 | 115.3 | 1, 13, 13, 13 |
| tos_b | 30.5 | 29.1 | 137.2 | 13, 16, 15, 16 |
| tos_c | 30.3 | 30.3 | 128.4 | 29, 13, 18, 22 |
Is the picture clean around the graphics? (percent of pixels that differ by more than 12 grey levels from a plain encode of the same clip)
| Clip | Outside the title box while it is settled | Outside the lower-third box while it is settled | Frames with no graphic at 0.5, 6.5, 12.5 and 30 s | Inside the title box (text is there) | Inside the lower-third box |
|---|---|---|---|---|---|
| tos_a | 0 | 0 | 0, 0, 0, 0 | 16.2 | 28.3 |
| tos_b | 0 | 0 | 0, 0, 0, 0 | 20.4 | 26.3 |
| tos_c | 0 | 0 | 0, 0, 0, 0 | 20.5 | 27.4 |
Where the graphics sit in the 1920x1080 frame (the transparent renders)
| Graphic | Box left, top, right, bottom (px) | Left / right margin (px) | First and last frame with any picture (s) | Touches an edge |
|---|---|---|---|---|
| title | 158, 206, 1562, 860 | 158 / 358 | 0.42 to 4.79 | no |
| lower third | 148, 694, 1728, 932 | 148 / 192 | 0.46 to 4.33 | no |
Reproduce it
"""Motion graphics over real footage: two HyperFrames compositions rendered with a transparent background, laid over a clip with FFmpeg.
usage: python pipeline_overlay_graphics.py clip.mp4 workdir
python pipeline_overlay_graphics.py --overlay-only workdir "NAME" "ROLE" (render just the lower third, for a text-fit check)
Needs HyperFrames (set HF to the hyperframes command), ffmpeg (set FFMPEG), and the two composition folders (set LT_TEMPLATE and TITLE_TEMPLATE
to folders holding index.html and gsap.min.js: the kicker-name lower third and the calm title card from our effects pages).
Prints one JSON line with the seconds each stage took.
Steps: write the exact text into each composition, render each as a ProRes 4444 MOV with alpha (1920x1080, 24 fps, 5 s), place them on the clip
(title card at 1 s, lower third at 7 s) and encode. The clip is cover-cropped to 1920x1080 at 24 fps.
"""
import json
import os
import shutil
import subprocess
import sys
import time
FFMPEG = os.environ.get("FFMPEG", "ffmpeg")
HF = os.environ.get("HF", "hyperframes")
LT = os.environ["LT_TEMPLATE"]
TT = os.environ["TITLE_TEMPLATE"]
NAME = os.environ.get("LT_NAME", "Alexandria Montgomery-Ames")
ROLE = os.environ.get("LT_ROLE", "Director of Platform Reliability and Developer Experience")
KICKER = os.environ.get("LT_KICKER", "Guest speaker")
HEADLINE = os.environ.get("TITLE_HEADLINE", "Three things to check before you publish a video")
TITLE_KICKER = os.environ.get("TITLE_KICKER", "Editing notes")
times = {}
def js(v):
return json.dumps(v, ensure_ascii=False)
def esc(s):
return s.replace("&", "&").replace("<", "<").replace(">", ">")
def build(template, out, subs):
os.makedirs(out)
src = open(os.path.join(template, "index.html"), encoding="utf-8").read()
for a, b in subs:
assert a in src, a
src = src.replace(a, b, 1)
open(os.path.join(out, "index.html"), "w", encoding="utf-8").write(src)
shutil.copy(os.path.join(template, "gsap.min.js"), out)
def render(comp, variables):
subprocess.run([HF, "render", ".", "-o", "alpha.mov", "--fps", "24", "--workers", "2", "--quality", "high", "--quiet", "--format", "mov", "--variables", js(variables)],
cwd=comp, check=True, capture_output=True)
return os.path.join(comp, "alpha.mov")
def lower_third(work):
comp = os.path.join(work, "lt")
build(LT, comp, [(">Short Name<", ">" + esc(NAME) + "<"), (">Job title or role<", ">" + esc(ROLE) + "<")])
return render(comp, {"plate": False, "kicker": KICKER})
def title_card(work):
comp = os.path.join(work, "title")
build(TT, comp, [(">Your headline goes here<", ">" + esc(HEADLINE) + "<")])
return render(comp, {"plate": False, "kicker": TITLE_KICKER})
if sys.argv[1] == "--overlay-only":
work = os.path.abspath(sys.argv[2])
if os.path.isdir(work):
shutil.rmtree(work)
os.makedirs(work)
NAME, ROLE = sys.argv[3], sys.argv[4]
lower_third(work)
print(json.dumps({"overlay": os.path.join(work, "lt", "alpha.mov")}))
sys.exit(0)
clip, work = os.path.abspath(sys.argv[1]), os.path.abspath(sys.argv[2])
if os.path.isdir(work):
shutil.rmtree(work)
os.makedirs(work)
# 1. lower third with the exact name and role, rendered with a transparent background
t0 = time.perf_counter()
lt_mov = lower_third(work)
times["render_lower_third_s"] = round(time.perf_counter() - t0, 2)
# 2. title card with the exact headline
t0 = time.perf_counter()
tt_mov = title_card(work)
times["render_title_card_s"] = round(time.perf_counter() - t0, 2)
# 3. place both on the clip and encode (title at 1 s, lower third at 7 s, five seconds each)
t0 = time.perf_counter()
fc = ("[0:v]scale=-2:1080,crop=1920:1080,fps=24,setsar=1[b];[1:v]setpts=PTS+1/TB[t];[2:v]setpts=PTS+7/TB[l];"
"[b][t]overlay=0:0:format=auto:eof_action=pass[bt];[bt][l]overlay=0:0:format=auto:eof_action=pass,format=yuv420p[v]")
subprocess.run([FFMPEG, "-v", "error", "-y", "-i", clip, "-i", tt_mov, "-i", lt_mov, "-filter_complex", fc, "-map", "[v]", "-map", "0:a", "-c:v", "libx264", "-crf", "20", "-preset", "medium",
"-c:a", "aac", "-b:a", "128k", "-t", "60", os.path.join(work, "final.mp4")], check=True)
times["composite_s"] = round(time.perf_counter() - t0, 2)
print(json.dumps(times))
# run: python pipeline_overlay_graphics.py clip.mp4 workdirThe exact script we ran for the timings. It needs HyperFrames (set HF to the hyperframes command), ffmpeg, and the two composition folders from our effects pages (set LT_TEMPLATE and TITLE_TEMPLATE; each holds index.html and gsap.min.js). Run it once per clip.
Method and limits
- We checked the pixels around the graphics and the text fit. We did not run a flash check on the composite, and we did not check the animation timing against the speech.
- Legibility is the average brightness behind the text and a contrast ratio of white against it, with grey levels converted to luminance by a gamma of 2.2. It is an estimate, not a readability test.
- One lower third, one title card and one set of text. Non-Latin scripts and very long text were not tested apart from the one longer name.
- CPU only, on a laptop shared with other work. 0 runs were discarded and redone because another encoder, browser or script of ours was busy during them. Windows background processes (the antivirus, the screensaver, search) did use CPU during the runs; they are listed in the result file, and the run times carry that noise.
- Footage: Tears of Steel, (CC) Blender Foundation, mango.blender.org, CC-BY 3.0.
Page checked on Nov 4, 2026.