Building an affordable video pipeline: Gemini 3.8, Antigravity, and HyperFrames

Creating consistent video content as a developer or solo creator is notoriously demanding. If you try to speed things up with AI video tools, you quickly run into a different wall: cost.

Most commercial AI video platforms operate on cloud-based credit models. You pay a recurring subscription, but every minute of video rendering burns through credits. If you notice a typo in a title card, want to nudge an overlay 10 pixels to the left, or need to re-cut a five-second pause, you have to submit another cloud render job and burn more credits. For high-volume short-form content, the bill adds up fast.

Over the past few weeks, I wanted to explore a more sustainable alternative. By pairing Google Gemini 3.8, Google Antigravity, and HeyGen's open-source video framework HyperFrames, I set up a local-first, code-driven video editing pipeline that renders high-quality vertical videos with zero cloud rendering fees.

Here is how the pieces fit together and why this workflow has become my preferred way to build programmatic video.

The problem with cloud video generation

Cloud AI video generators are designed around remote servers running heavy GPUs. That makes sense for generative video diffusion models, but much of practical short-form editing does not need diffusion.

Most creator vlogs, tech explainers, and educational videos rely on:

• Trimming raw footage and removing dead air.
• Structuring narrative beats and punch-in zooms.
• Adding clean, readable subtitle bands.
• Overlaying branded graphics, titles, and lower thirds.
• Syncing subtle sound effects to visual transitions.

Doing those deterministic editing steps on a cloud server charging $10 to $30 per hour of render time is inefficient. What developers need is what we already have for web apps: a local build system, declarative components, and instant local compilation.

HyperFrames by HeyGen: video declared as HTML

This is where HyperFrames comes in. Developed by HeyGen and open-sourced on GitHub (heygen-com/hyperframes), HyperFrames approaches video editing not as a closed timeline binary, but as code.

Specifically: it renders video from HTML.

In HyperFrames:

• A composition is an HTML document.
• Video clips, graphics, and captions are DOM elements styled with standard CSS.
• Timing and layer positions are declared cleanly with attributes like data-start, data-duration, and data-track-index.
• Smooth animations and transitions are driven by GSAP (GreenSock) timelines.
• Reusable components (lower thirds, spotlight cards, quote boxes, terminal windows) can be fetched from the community registry or written by hand.

When it is time to export, HyperFrames runs a headless Chromium instance and FFmpeg locally on your computer. It seeks through the DOM timeline frame-by-frame, captures the visual output, and encodes the final MP4.

Because the entire render runs locally on your own hardware (such as an Apple Silicon Mac), you pay zero cloud rendering fees. Re-rendering with a corrected word or a new color takes a quick command-line run, not a credit reload.

Gemini 3.8: high-speed multimodal reasoning and timing precision

Declaring video in HTML solves the rendering cost, but manually writing hundreds of lines of timing data, clip cuts, and CSS coordinates would be tedious. That is where Google Gemini 3.8 comes in.

In this workflow, Gemini 3.8 Flash (and Flash High) handles the cognitive editing work:

• Pacing and transcription: Analyzing word-level transcripts and identifying natural boundaries, eliminating false starts, and suggesting punch-in cuts without breaking the speaker's cadence.
• Narrative structuring: Grouping raw footage into cohesive acts or chapter beats (such as dividing an 8-minute vlog into thematic 50-second shorts).
• Code generation: Writing valid HTML and GSAP code that strictly matches the HyperFrames JSON schema and track guidelines.
• Speed and token efficiency: Because Gemini 3.8 is lightweight and fast, generating full composition files or revising timings happens in seconds at minimal API cost.

Instead of asking AI to generate raw video pixels, we use AI for what it does best: understanding language, planning structure, and writing deterministic code.

Google Antigravity: the agentic glue

Having an intelligent model and a local renderer still leaves the challenge of workflow friction. If you have to copy JSON from a web chat, save files manually, test them in a terminal, and paste error logs back into a chatbox, the workflow breaks down.

Google Antigravity provides the agentic development environment that connects everything:

• Direct file manipulation: Antigravity reads source media metadata (resolution, frame rate, duration) and directly writes the project files (index.html, hyperframes.json, compositions/*.html).
• Autonomous CLI execution: It can run local probing tools (mdls, ffprobe), execute transcription scripts, and trigger the HyperFrames build and render CLI (npx hyperframes).
• Inspection and verification: Antigravity can inspect output logs, catch schema validation issues, and verify that the rendered video file exists with the expected dimensions and duration.

This turns video editing into a pair-programming experience. I provide the creative direction and raw footage; Antigravity and Gemini 3.8 draft the storyboard, assemble the tracks, and run the local render.

Putting the stack to work on real footage

Earlier today, I tested this exact pipeline on raw vlog footage from my web developer internship.

Using Antigravity and Gemini 3.8, we:

1. Probed the raw 1080p footage shot on my Insta360 Ace Pro 2.
2. Structured two complete narrative storyboards: one focusing on office teamwork and a storefront project demo, and another focusing on frontend architecture and keynote advice.
3. Created two HyperFrames projects with customized brand styling: charcoal backgrounds (#20252B), white typography in Plus Jakarta Sans, and cobalt blue accents (#2457C5).
4. Rendered two crisp 1080x1920 vertical videos (Office life at 50.7s and Lessons and recognition at 59.0s) directly on my Mac.

The entire process required zero cloud rendering subscriptions, zero closed-source video software, and resulted in clean, version-controlled code that lives in Git alongside my other repositories.

Trade-offs and practical considerations

As promising as this workflow is, it is important to be realistic about its limits:

• Technical barrier: Because compositions are written in HTML, CSS, and GSAP, tweaking advanced motion effects requires web development comfort. It does not replace a visual timeline for editors who prefer manual mouse scrubbing.
• Local machine performance: Headless browser rendering relies on your local CPU and GPU. On modern Apple Silicon or performant desktop machines, 1080p renders run smoothly, but older laptops might find frame-by-frame browser capture slower than native GPU pipelines.
• Audio syncing: Managing audio fades and precise word-level synchronization requires clean timestamps from local transcription tools like Whisper.

The bigger picture for developer-creators

For technical creators, web developers, and small teams producing educational or short-form content, the combination of Gemini 3.8, Antigravity, and HyperFrames represents a major shift.

It replaces expensive per-minute SaaS billing with open web standards. It turns video timelines into version-controlled text files that can be diffed, branched, and automated. Most importantly, it proves that with the right agentic tools, you can build a professional, automated content pipeline entirely on your own terms.