Object additive buildup — an entire lifespan in a single locked shot

What the technique is

One source plate. A locked frame, locked camera, locked lighting. Now run additive object-edit passes on a compressed timeline. Each pass takes the previous frame plus the next prompt and writes only inside a defined region. The result reads as the same place at different times.

• Frame 1: empty surface (foundation, bare branch, blank canvas).
• Frame 2-3: the first additive pass writes the underlayer.
• Frame 4-6: the bulk material fills in.
• Frame 7: the finished, photogenic state.
• Frame 8-10: weathering / aging settles in if the script wants it.

When to use it

A locked plate is a stage. When only the surface of the stage changes — material building, growing, weathering — the audience reads each new state as the same place at a different time. The brain fills in the years between the cuts. They never see a time-lapse counter. They feel time pass.

Use it anywhere the script calls for a single image to do the work of a paragraph.

How Hybrig encodes it

1. Source plate. Start with one locked-framing source. Real photo if you have it, Flux still if you do not. The framing has to hold across every subsequent pass.
2. Region of edit. Define the area where the object materializes. Everything outside this region is held; everything inside is the variable.
3. Sequenced cloud passes. Run the cloud edit pass once per state in the sequence. Bare, underlayed, half-built, finished, weathered. One job at a time (per [[feedback_no_batch_paid_jobs]]). Each pass takes the previous frame plus the next prompt.
4. Timeline assembly. Assemble the per-state stills in a Remotion timeline with cuts paced to the script. Crossfades on the build steps, hard cuts on the wear steps if the script wants the audience to feel time jumping.

Object-edit passes on a held plate are metered cloud work today. This is a hero-beat technique. One or two per spot, in the moment where the audience needs to feel a long story compressed into a short window. Do not run it on every still in the slideshow — the unit economics break. See [[project_cloud_polish_by_beat_type]].

The render-process workflow

Six steps run in order. Each cloud edit pass feeds the next — the chain is strictly sequential because the next state has to paint over the previous state without breaking framing or lighting registration.

Step 1 — Source plate

Node: image-upload for a real photo, or flux-lora-still for a generated source. In: a still image or a prompt describing the empty / bare initial state. Out: a single still representing frame 1 of the eventual sequence — bare surface, no built material in the region of edit yet. Why: every subsequent state in the buildup paints over this plate. Framing and lighting of the source have to hold across every pass, which is why we start with one image rather than re-shooting.

Step 2 — Region mask

Node: not yet a dedicated palette node — see open questions. Today the region is keyed by hand as a bounding shape (rectangle or silhouette) and passed inline with each cloud edit job. In: the source plate plus the region-of-edit outline. Out: an alpha mask describing which pixels each downstream cloud pass is allowed to rewrite. Everything outside the mask is held identical across all N states. Why: the cloud pass needs explicit instructions for what to leave untouched. The stage analogy holds only if the stage holds.

Step 3 — N sequential object-edit passes

Node: not yet a dedicated palette node — see open questions. Today each state in the sequence is a manual cloud handoff. In: the previous state’s output frame plus the region mask plus a prompt describing the next state (bare, underlayed, half-built, finished, weathered). Out: a new still where the pixels inside the region have advanced to the next state and the pixels outside the region are pixel-identical to the previous state. Why: each pass builds on the previous one so continuity is preserved. Run one job at a time per [[feedback_no_batch_paid_jobs]] — metered cloud compute gets billed by the second and the sequential dependency means batching cannot help.

Step 4 — Timeline assembly

Node: remotion-timeline. In: the N per-state stills from step 3, in earliest-to-latest order. Out: a Remotion composition that holds each still for a script-paced beat (12-30 frames is typical) and transitions to the next with the chosen easing — crossfade on build steps, hard cuts on wear steps. Why: Remotion owns the timeline assembly. The pacing of the buildup is what makes time-passing readable; a single-rhythm cut would feel mechanical.

Step 5 — Optional motion polish on transitions

Node: not yet a dedicated palette node — see open questions. In: a single state-to-state transition from step 4 plus a brief describing the natural motion (settling, growing, sliding). Out: a short motion clip that interpolates between the two stills with physically plausible movement and slots back into the Remotion timeline replacing the hard cut. Why: reserved for hero beats. The local crossfade is usually enough; cloud motion polish is for the closing or hero state-change beat where the audience will linger on the transformation. Per [[project_cloud_polish_by_beat_type]] one or two per spot, never on every transition.

Step 6 — Encode and emit

Node: video-output. In: the assembled timeline from step 4 (or step 5 if motion polish ran). Out: an MP4 on disk tracked in /operations. Why: terminal node.

Studio workflow shortcut

The object additive buildup template is not yet a one-click entry in the /studio palette — the mask + N sequential edit stage runs as manual cloud handoffs today. Once the mask and object-edit nodes land (see open questions), the template will live at /studio?template=object-additive-buildup and drop the full chain onto the canvas in one click. Until then, assemble it by hand using the node types named in section 4.

Example use cases

• Construction and home services. Empty lot to finished structure to weathered exterior on the same locked frame. Roof bare deck to finished shingles. Walls framed to drywalled to painted.
• Product launches. Empty product table to fully-styled hero shot in compressed assembly. Components arriving, snapping together, branded packaging closing around them.
• Nature and garden content. Bare branch to bud to bloom to fruit on the same locked tree. Empty garden bed to seedling to harvest in fifteen seconds.
• Restoration and before/after. A faded paint job filling back in. A worn deck rebuilding itself. Visible step-by-step transformation that explains howthe change happened, not just that it did.

Open questions

• No dedicated region-mask node lives in the Studio palette today (templates.ts has no entry). Step 2 of the render-process workflow runs by passing a hand-keyed bounding shape inline with each cloud edit job.
• No dedicated cloud-object-edit node lives in the palette today (templates.ts has no entry). Step 3 is a manual cloud handoff per state. When the backing node lands, the workflow template will swap to it and the N-pass chain becomes a single drag-and-drop graph.
• Pacing-by-script automation — reading the VO cadence and sizing the build steps to land on stressed words — is a future pass. Today the pacing is hand-keyed in the timeline.
• Companion technique on the same locked plate is the object-removal layer reveal at /learn/object-removal-layer-reveal. Same stage, opposite direction: buildup adds material, removal exposes what is beneath.