Can HyperFrames Replace After Effects? I Tested My Own Videos

Published
Oct 6, 2026
Duration
6:35
Click to load the YouTube player

A useful first HyperFrames project is a short explanation you have already recorded. Keep the voice, bring in the screen recordings or images that support it, and ask your coding agent to build the graphics around what is being said. You should finish with an editable composition and an exported clip you can inspect against the original material.

This is also a manageable way to compare HyperFrames with After Effects. Use the same inputs and a specific editing task: five project cards that appear when they are named, or a diagram that explains which tool does which job. A fast render tells you little if the viewer cannot follow the explanation.

The worked examples here come from two Superbash tests: a 25-second recreation of an existing Sol versus Astra sequence and a roughly 21-second explanation of an Opus/Unreal game workflow. They show the construction and review process, including the revisions. The command examples below are checked against current HyperFrames documentation; they are added setup guidance, not a claim that a new edit was rendered for this article.

Before you start: choose one explanation and gather its inputs

Pick a passage with a clear beginning and end. Twenty to thirty seconds is enough to test footage, text, a few timed reveals and audio without creating an entire episode’s worth of revisions. Listen to the passage before choosing a visual style. Write down what the viewer needs to understand at each point.

For a recreation, gather the original presenter recording, its narration, the project footage and the existing finished edit. The finished edit is the comparison reference. The separate recordings are the material from which the new composition is built. Feeding the flattened finished video into a player would preserve its appearance, but it would not give you editable project cards or labels.

For a new explanation, gather the evidence first: the relevant app recording, the generated artwork, the result inside the target application, and any labels needed to connect them. Keep the original filenames and note which section of each recording is useful. A folder full of vaguely named videos makes it easy for an agent to pick a visually plausible but irrelevant moment.

Use a short preparation table:

Narration cueWhat the viewer should seeSource to supplyCheck
A project is namedIts card and a recognizable resultThat project’s recordingThe correct project appears at the spoken cue
A model setup is explainedLabels plus the relevant previewsSetup capture and project footageLabels remain readable while previews move
A tool’s role is explainedThe tool and its outputApp capture plus resulting assetThe relationship is explicit
A detail is discussedA tight view of that detailOriginal high-resolution captureThe crop preserves the evidence

This table is a suggested planning aid. Fill its timings from your own recording; the source video’s publication timestamps are not the timing of your new composition.

Original voice and source footage feeding a new editable sequence.
The source explanation at 2:27 separates the original narration and project footage from the rebuilt composition. Supply those editable inputs as well as the reference export. Source frame; open the image for full size.

Decide whether you are preserving the existing soundtrack. Both source tests retained recorded narration and used existing footage. The second required neither a generated presenter nor a replacement voiceover. There is no reason to add either just to use an AI editing tool.

Set up a local composition the agent can edit

For local work, HyperFrames requires Node.js 22 or later and FFmpeg. You also need an AI coding environment that can read the project files and the HyperFrames skills. Check the dependencies in your terminal:

node --version
ffmpeg -version

The official quickstart documents those prerequisites. Use your platform’s normal installation route if a dependency is missing, then repeat the version check. These checks establish availability, not whether a particular composition is ready to render.

Create a separate project directory and install the skills for your coding environment:

npx hyperframes skills
npx hyperframes init narrated-clip
cd narrated-clip

The current HyperFrames CLI guide documents project creation and the edit/check/render loop. Follow any prompts in your installed version. For the installed version’s options, use npx hyperframes init --help. The skill installer is documented in the project’s scaffolding reference.

HyperFrames stores the composition as HTML, CSS and animation code. In its current authoring convention, index.html is the root, scenes live under compositions/, and local media lives under assets/. The agent needs to load the HyperFrames authoring skill before changing these files. It contains timing and media rules that a generic web-page generator will not know. See the official authoring skill.

The practical difference from an ordinary website is time. A card must have a defined entrance, visible duration and exit; a renderer must be able to seek to a frame and get the expected state. Random movement, live network content or a timer that happens to fire during playback can break that expectation. Let the agent use the framework’s timeline conventions rather than improvising a browser animation that only works when played from the beginning.

The Superbash tests used Codex with the HyperFrames skill and a local browser preview. The new desktop assistant’s drawing and commenting controls were explicitly untested. You can evaluate the file-based workflow without treating those separate controls as a demonstrated feature of these tests.

Give the agent a timing brief, then review one pass

Describe the desired explanation before requesting animation. A useful brief identifies the source recording, the content that must remain editable, and what a viewer should understand. For example:

Build a short explanation around this narration. Preserve its wording and timing. Reveal each project card when its name is spoken, using the supplied footage for that project. Keep labels editable. Crop recordings to the relevant result, and keep the presenter inset clear of labels. Show me the composition before the final export.

That is an adapted starting brief, not the exact prompt used in the source. Replace the general references with your filenames and measured cue times. If you want a close recreation, supply the old export as a reference and identify the details that must match: font, card order, preview start frames, spacing and reveal timing.

Ask for one complete first pass of the chosen passage. Reviewing a complete twenty-second explanation is more useful than polishing its opening card while the remaining scenes do not exist. Watch it with sound, then pause at each cue. Confirm that the displayed footage supports the sentence being spoken.

In the Sol/Astra test, the rebuilt sequence kept the five-project structure, racing demo and Codex setup graphic. It retained the narration and editable text and graphics. The font differed, and some moving previews began on different frames. Those are concrete review findings: acceptable for a fresh explanation, but unfinished if the brief requires a faithful visual match. See the comparison from 2:11.

After Effects and HyperFrames versions showing the same project cards.
At 2:35, four of the five cards have appeared in both versions. The arrangement is comparable; use playback to judge the remaining reveal timing and moving preview frames. Source frame; open the image for full size.

Use separate feedback for content and timing. “Use the mechanical-watch recording for this card” fixes a source-selection problem. “Reveal the card as the project name begins” fixes synchronization. “Match the reference font” fixes visual consistency. Combining all three into “make it closer” makes the next revision harder to judge.

Build diagrams around the order of the explanation

A diagram works best when it answers a question the narration is already raising. In the second test, that question was how Opus, Cursor, Blender, Unreal Engine and Higgsfield fit together. Showing all five names at once would give the viewer another list to decode while listening.

The useful sequence was to establish the coordinator first, then reveal the tools and their outputs. Opus in Cursor coordinated the work; Blender made geometry; Unreal assembled the game; Higgsfield provided artwork. The composition used the actual conversation and application recordings, so the diagram connected labels to evidence rather than relying on generic icons. Watch the example from 3:04.

A diagram placing Opus in Cursor above Blender, Unreal Engine and Higgsfield.
The completed diagram at 3:51 gives each tool a role and a visible output. It was built up in stages with the narration; this still shows the resulting relationship. Source frame; open the image for full size.

For your own workflow explanation, write one plain sentence for each connection: “This tool produces this asset, which is used here.” Then decide when that connection should appear. Keep the coordinator visible long enough for later branches to have a clear parent. A viewer should not have to remember a node that vanished before its output appeared.

After the first pass, watch without pausing. If you understand the diagram only when inspecting a still, it may be too dense or too fast. Reduce competing movement, hold a relationship longer, or split the explanation into two scenes. The source supports one short diagram sequence; a full episode will need the same review across many scenes and transitions.

Troubleshoot layout, framing and source selection

Use npx hyperframes lint for structural feedback while the agent is building the composition. After the edit is ready, run the full check and review snapshots from the project directory:

npx hyperframes check --json
npx hyperframes snapshot --review

The current checking reference describes these checks and review snapshots. Fix reported errors, and inspect whether browser sampling actually ran. A skipped browser pass or zero sampled frames is not evidence that the layout passed. Open the generated snapshot files and inspect the relevant scenes, including transitions.

Automated checks are useful for overflow and contrast. They cannot decide whether a screen recording is the right evidence for a sentence. The source tests needed both kinds of review: a setup sample had clipped captions and poor text contrast, while the actual project clips needed tighter screen crops and an adjusted presenter inset. See the revision discussion at 3:58.

Generated artwork beside source labels about cropping unrelated UI and keeping useful context.
The framing guidance at 4:16 keeps the generated results and useful context while removing unrelated UI. The annotations belong to the source video; this figure is an authentic frame crop. Source frame; open the image for full size.

When a screenshot is hard to read, identify why. If it contains a useful result surrounded by project sidebars, crop the irrelevant UI. If the selected result itself has tiny text, give it more room or use a detail shot. Enlarging a whole application window usually enlarges the distractions too.

Check the presenter inset separately. It should leave the evidence and labels visible throughout the passage, including when new cards appear. Review the composition at the size people will actually watch it. A label that fits inside a box on a large monitor can still be unreadable on a phone.

When captions clip, fix the size, line breaks or available space. When contrast is poor, change the foreground/background relationship. When the wrong footage appears, replace the source selection. These are different faults, and a single request to “improve the layout” may leave the real problem untouched.

Preview, export and verify the exported file

Once the checks and still-frame review are satisfactory, run the preview and use the project URL it prints:

npx hyperframes preview

Play the whole passage with sound. You can continue editing the same project in the HyperFrames desktop app if you prefer; the source tests used the browser preview. Keep the distinction clear when comparing your own setup with the recorded results.

After approving that preview, render an MP4:

npx hyperframes render --output narrated-clip.mp4

The rendering guide documents this basic command. Set the intended resolution and frame rate in the composition and verify the output matches them. The source clips were exported at 1080p and 30 fps; those measured outputs are not a guarantee about every project’s defaults.

Open the exported file itself. Check the first and last spoken words, the important reveals, the ending hold and the audio. Compare an obvious spoken cue near the beginning and another near the end with the source. If you detect a mismatch, investigate whether it is a fixed offset, a cut error or increasing drift before moving the whole track. Listening and lip-sync inspection are useful checks; they do not justify a claim of zero measurable offset without an actual measurement.

The team’s checks found no measurable audio offset in the two tested exports. That mattered because an earlier After Effects episode had needed an audio-offset correction. It establishes a result for those files, not permanent immunity from sync errors. The export discussion starts at 4:35.

Compare the complete editing job before changing workflows

Record four times separately: preparing the inputs, constructing the scenes, reviewing and revising, and exporting. The roughly one-minute HyperFrames figures in the source refer to local exports of the two short clips on the test Mac. They exclude the work before the render.

Ron also described After Effects jobs taking at least about half an hour in the team’s experience. The workloads were not matched, so those observations cannot support a thirty-times-faster full-episode claim. Compare equivalent passages with the same required finish, then include the time it takes to make a later correction.

Before calling the project reusable, change one label and one cue. Can you find the editable element, make the change without rebuilding unrelated scenes, and export a correct revision? That tests the benefit you wanted from a shared project. Saving only the MP4 throws away that part of the result; retain the composition, media, fonts and brief together.

The earlier After Effects work also used arrows and outlines to explain the mechanical watch, plus evidence screenshots and animated highlights. It still needed editorial revisions: separating images from their labels, adjusting reveals and correcting the Dots export’s audio offset. Carry those review requirements into either tool.

After Effects remained Superbash’s established full-episode route. The team had already used it for a nearly seven-minute Sol comparison and an almost six-minute Dots episode, and had accumulated Envato templates and visual instructions. Those references reduce the work of communicating the desired style. HyperFrames may also benefit from reusable references, but this test did not replace that entire library. See the workflow decision from 5:00.

Use your first short clip to decide where HyperFrames earns a place: a timed explanation, an editable diagram or a section built from existing recordings. Expand when that work survives revisions and export checks. Your next milestone is a reliable section of an episode, with readable evidence and correct sound, that you can still edit tomorrow.