September 1, 2026AIExplore

How to Use Keyframes and Loops in Luma

Control start and end frames, extend clips, and create looping motion in Dream Machine with clear transition prompts.

Dream Machine supports Keyframes for start and end frame control, Extend for lengthening clips, and Loop for repeating motion. Official Keyframes help: set start and end frames from uploads or generated images, then prompt the transition. Official Extend help: leave the prompt blank for a natural continue, or guide with text, with an optional end keyframe. Type loop or looping video, or use Loop UI where available. Overview: /explore/luma.

This guide covers the workflow in detail. Related Luma articles: /blog/how-to-edit-and-refine-videos-iteratively-in-luma, /blog/how-to-master-camera-motion-controls-in-luma, /blog/how-to-turn-images-into-videos-with-luma.

When this workflow is the right job

Use keyframes when both ends of a transition are known. Use Extend when you like a clip and need more time. Use loop when the motion must repeat for social or ambient use.

Step by step workflow

1. Set start and end states

Choose compatible lighting and subject scale across keyframes.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Start: peaceful meadow at dawn End: starry night with fireflies over the same meadow Match: horizon line and meadow layout. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Start: peaceful meadow at dawn End: starry night with fireflies over the same meadow Match: horizon line and meadow layout" that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure luma specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Start: peaceful meadow at dawn End: starry night with fireflies over the same meadow Match: horizon line and meadow layout" requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

2. Prompt the transition

Describe how time or motion should travel between frames.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Smooth transition from dawn to night, slow camera push, consistent landscape, fireflies appear gradually.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Smooth transition from dawn to night, slow camera push, consistent landscape, fireflies appear gradually." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Smooth transition from dawn to night, slow camera push, consistent landscape, fireflies appear gradually." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

3. Extend when you need length

Continue with blank prompt for natural motion, or guide with text. Optional end keyframe for a target.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Extend: continue the meadow scene into gentle dusk, keep camera path, no new characters.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Extend: continue the meadow scene into gentle dusk, keep camera path, no new characters." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Extend: continue the meadow scene into gentle dusk, keep camera path, no new characters." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

4. Add loop after timing works

Validate cadence on a non loop preview, then request loop or use Loop UI.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Looping video of fireflies over a quiet meadow, gentle repeating motion, static camera, soft night lighting, seamless loop.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Looping video of fireflies over a quiet meadow, gentle repeating motion, static camera, soft night lighting, seamless loop." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Looping video of fireflies over a quiet meadow, gentle repeating motion, static camera, soft night lighting, seamless loop." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Practical keyframe, extend, and loop prompts

Dawn to night meadow

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Start: peaceful meadow at dawn. End: starry night with fireflies over the same meadow. Prompt: smooth transition, slow camera push, consistent landscape.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Start: peaceful meadow at dawn. End: starry night with fireflies over the same meadow. Prompt: smooth transition, slow camera push, consistent landscape." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Start: peaceful meadow at dawn. End: starry night with fireflies over the same meadow. Prompt: smooth transition, slow camera push, consistent landscape." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Extend dusk

Loop fireflies

City day to night

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Start: busy plaza at late afternoon. End: same plaza with night lights. Prompt: time lapse feel, locked wide camera, people density softens.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Start: busy plaza at late afternoon. End: same plaza with night lights. Prompt: time lapse feel, locked wide camera, people density softens." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Start: busy plaza at late afternoon. End: same plaza with night lights. Prompt: time lapse feel, locked wide camera, people density softens." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Product open to close

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Start: bottle closed on stone. End: bottle with cap beside it. Prompt: gentle hand free transition, soft studio light, slow orbit.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Start: bottle closed on stone. End: bottle with cap beside it. Prompt: gentle hand free transition, soft studio light, slow orbit." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Start: bottle closed on stone. End: bottle with cap beside it. Prompt: gentle hand free transition, soft studio light, slow orbit." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Season leaf

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Start: green tree lane. End: same lane with autumn leaves. Prompt: seasonal shift, slow push, keep road center.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Start: green tree lane. End: same lane with autumn leaves. Prompt: seasonal shift, slow push, keep road center." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Start: green tree lane. End: same lane with autumn leaves. Prompt: seasonal shift, slow push, keep road center." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Extend ocean

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Extend: continue waves with the same camera height, no boats, soft overcast.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Extend: continue waves with the same camera height, no boats, soft overcast." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Extend: continue waves with the same camera height, no boats, soft overcast." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Loop waves

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Looping video of gentle waves on a shore, seamless cycle, locked camera, soft morning light.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Looping video of gentle waves on a shore, seamless cycle, locked camera, soft morning light." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Looping video of gentle waves on a shore, seamless cycle, locked camera, soft morning light." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Interior lights on

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Start: room in blue hour dusk. End: same room with lamps on. Prompt: lights warm up gradually, static camera.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Start: room in blue hour dusk. End: same room with lamps on. Prompt: lights warm up gradually, static camera." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Start: room in blue hour dusk. End: same room with lamps on. Prompt: lights warm up gradually, static camera." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Extend forest path

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Extend: keep walking the path forward, same fog density, no new landmarks.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Extend: keep walking the path forward, same fog density, no new landmarks." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Extend: keep walking the path forward, same fog density, no new landmarks." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Loop steam

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Looping video of steam rising from a mug, seamless, locked macro, warm window light.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Looping video of steam rising from a mug, seamless, locked macro, warm window light." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Looping video of steam rising from a mug, seamless, locked macro, warm window light." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Keyframe wardrobe

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Start: coat on rack closed. End: coat slightly open. Prompt: fabric settles, soft studio light, minimal camera.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Start: coat on rack closed. End: coat slightly open. Prompt: fabric settles, soft studio light, minimal camera." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Start: coat on rack closed. End: coat slightly open. Prompt: fabric settles, soft studio light, minimal camera." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Extend rain

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Extend: continue light rain and reflections, keep architecture, no new signage.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Extend: continue light rain and reflections, keep architecture, no new signage." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Extend: continue light rain and reflections, keep architecture, no new signage." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Loop neon

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Looping video of neon sign flicker reflections on wet street, seamless, static medium.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Looping video of neon sign flicker reflections on wet street, seamless, static medium." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Looping video of neon sign flicker reflections on wet street, seamless, static medium." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Blank extend

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Extend with blank guidance for a natural continue of the current motion.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Extend with blank guidance for a natural continue of the current motion." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Extend with blank guidance for a natural continue of the current motion." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

End keyframe target

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Extend with end keyframe: reach the night plaza still, keep camera locked, gradual light change.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Extend with end keyframe: reach the night plaza still, keep camera locked, gradual light change." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Extend with end keyframe: reach the night plaza still, keep camera locked, gradual light change." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Loop fabric

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Looping video of curtains moving in a soft breeze, seamless, locked wide, overcast window light.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Looping video of curtains moving in a soft breeze, seamless, locked wide, overcast window light." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Looping video of curtains moving in a soft breeze, seamless, locked wide, overcast window light." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

How to improve keyframes, extends, and loops

Match lighting and subject scale between start and end keyframes.

Official Extend Keyframes content notes extended outputs up to 9 seconds in image keyframe workflows. Confirm live UI limits in your account.

Ray2 learning content notes longer extends may reduce quality. Prefer shorter extends when fidelity matters.

Do not request loop before motion cadence is validated.

Avoid stacking new camera moves during extend on top of the original path.

Leave the Extend prompt blank when natural continuation is enough.

Use end keyframes when you need a targeted endpoint rather than open continuation.

Keep related prompts on one board so continuity improves.

If the middle invents objects, narrow transition language and extend again.

Loops need repeating subjects: waves, steam, fireflies, fabric. Narrative one way actions loop poorly.

Draft explores before committing credits to long extends.

Combine Modify after extend when grade needs a fix but length is right.

Prompting guidance that holds up in review

Describe both ends clearly, then the bridge in one short paragraph.

Name what must stay constant across the transition: horizon, product, camera height.

For loops, state seamless loop and prefer locked camera language.

For blank extends, say nothing if natural continue is the goal.

For guided extends, ban new characters and landmarks unless needed.

Limitations to respect

Live duration caps and quality tradeoffs can change. Confirm in product help rather than assuming a fixed maximum.

Longer extends can reduce quality per older Ray2 learning notes. Watch the middle carefully.

Incompatible start and end lighting produces muddy bridges.

One way story actions rarely loop cleanly.

Field tips from real boards

For campaigns, store start and end stills with the prompt template.

Check seam points on loops by playing several cycles.

Prefer static camera for many loop jobs so repetition stays clean.

When using character reference with keyframe Modify, follow official Ray3 Modify presence rules.

Match horizon lines and subject scale between start and end frames before you prompt the bridge.

Validate loop cadence on a non loop preview. Seamless requests cannot fix broken timing.

Blank Extend is enough when the motion should continue naturally without a new destination.

End keyframes help when the destination still is already approved and must be hit.

Waves, steam, and fabric loop cleanly. One way story actions usually do not.

If the middle invents landmarks, narrow the transition language and shorten the extend.

Play several loop cycles in a row. Seams hide when you only watch once.

Prefer locked camera for ambient loops so repetition stays readable on social feeds.

Store start and end stills with the template when the campaign needs repeatable bridges.

Confirm live duration limits in product help rather than assuming a fixed maximum from older posts.

For keyframe and loop delivery, reject any take that fails a one sentence subject and motion intent test before you queue another credit spend.

Match horizon lines and subject scale between start and end frames.

Validate loop cadence on a non loop preview first.

Blank Extend is enough when motion should continue naturally.

End keyframes help when the destination still is already approved.

Waves, steam, and fabric loop cleanly. One way stories usually do not.

If the middle invents landmarks, narrow transition language.

Play several loop cycles in a row to catch seams.

Prefer locked camera for ambient loops on social feeds.

Store start and end stills with the template for repeatable bridges.

Confirm live duration limits in product help before promising length.

Default generations are often short. Plan Extend as a second step in the timeline, not an afterthought.

Official keyframe extend help notes image keyframe extensions up to 9 seconds. Confirm the live UI.

Older Ray2 learning notes warn that longer extends can drop quality. Prefer shorter bridges when fidelity matters.

Dawn to night bridges need compatible landscapes more than poetic weather words.

For product open to close transitions, keep studio light identical on both stills.

Loop candidates should be inspected at the seam for pop and brightness jumps.

Ambient brand loops work best with subtle repeating motion and locked framing.

If blank Extend invents characters, add an explicit ban and guide with text next time.

Common mistakes

Keyframes with incompatible lighting between start and end
Requesting loop before timing is validated
Stacking new camera moves during extend
Expecting perfect quality on very long extends without checking live limits
Looping one way story actions
Leaving transition prompts vague when ends differ strongly

Related Luma articles: /blog/how-to-edit-and-refine-videos-iteratively-in-luma, /blog/how-to-master-camera-motion-controls-in-luma, /blog/how-to-turn-images-into-videos-with-luma. Return to /explore/luma for the broader guide set.