September 1, 2026AIExplore

How to Master Camera Motion Controls in Luma

Pick one Dream Machine camera move such as Pan, Orbit, Push In, or Crane, then refine speed and framing for cleaner clips.

Luma

Camera Motion controls in Dream Machine let you apply named moves after generating or uploading an image. Official camera motion help lists Pan, Orbit, Crane, Move, Push In, and Pull Out. On web, type Camera to choose movement styles. On iOS, use the prompt tray controls. Lead prompts with shot type and one camera move. Overview: /explore/luma.

This guide covers the workflow in detail. Related Luma articles: /blog/how-to-use-luma-dream-machine-for-text-to-video, /blog/how-to-use-keyframes-and-loops-in-luma, /blog/how-to-build-campaigns-and-reusables-in-luma.

When this workflow is the right job

Use named camera moves when motion must feel intentional. Prefer static language when faces or thin products warp. Prefer separate clips when you need multiple moves in an edit.

Step by step workflow

1. Choose one move

Pick Pan, Orbit, Crane, Move, Push In, or Pull Out. Add a speed word such as slow or gentle.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Camera plan Move: Push In Speed: slow steady Shot: medium product hero. 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 "Camera plan Move: Push In Speed: slow steady Shot: medium product hero" 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 "Camera plan Move: Push In Speed: slow steady Shot: medium product hero" 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. Lead the prompt

Put shot type and camera early, then subject and light.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Medium tracking shot of a chef plating pasta in an open kitchen, camera follows from the side, slow steady movement, warm practical lights, shallow depth of field.. 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 "Medium tracking shot of a chef plating pasta in an open kitchen, camera follows from the side, slow steady movement, warm practical lights, shallow depth of field." 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 "Medium tracking shot of a chef plating pasta in an open kitchen, camera follows from the side, slow steady movement, warm practical lights, shallow depth of field." 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. Generate with UI or text

Use Camera Motion UI after an image, or name the move in text. Keep a single behavior.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Orbit Right around a matte black sneaker on concrete, slow steady move, soft daylight, shallow depth of field, product stays centered.. 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 "Orbit Right around a matte black sneaker on concrete, slow steady move, soft daylight, shallow depth of field, product stays centered." 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 "Orbit Right around a matte black sneaker on concrete, slow steady move, soft daylight, shallow depth of field, product stays centered." 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. Split complex motion

If you need push in and pan, generate two clips and cut them in post.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Clip A: static medium of subject Clip B: slow orbit around product Edit: cut A to B. 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 "Clip A: static medium of subject Clip B: slow orbit around product Edit: cut A to B" 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 "Clip A: static medium of subject Clip B: slow orbit around product Edit: cut A to B" 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 camera motion prompts

Chef tracking

Orbit sneaker

Push in mug

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Slow push in on a ceramic coffee mug on a wooden table, steam rising, morning window light from the left, warm golden lighting.. 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 "Slow push in on a ceramic coffee mug on a wooden table, steam rising, morning window light from the left, warm golden lighting." 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 "Slow push in on a ceramic coffee mug on a wooden table, steam rising, morning window light from the left, warm golden lighting." 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.

Pull out plaza

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Pull Out from a busy plaza fountain to a wide establishing view, late afternoon light, gentle steady move.. 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 "Pull Out from a busy plaza fountain to a wide establishing view, late afternoon light, gentle steady move." 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 "Pull Out from a busy plaza fountain to a wide establishing view, late afternoon light, gentle steady move." 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.

Pan harbor

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Pan Right across a quiet harbor at blue hour, soft overcast light, muted blues, restrained speed.. 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 "Pan Right across a quiet harbor at blue hour, soft overcast light, muted blues, restrained speed." 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 "Pan Right across a quiet harbor at blue hour, soft overcast light, muted blues, restrained speed." 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.

Crane up ridge

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Crane Up from a trail sign to a mountain ridge at golden hour, long shadows, epic but slow.. 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 "Crane Up from a trail sign to a mountain ridge at golden hour, long shadows, epic but slow." 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 "Crane Up from a trail sign to a mountain ridge at golden hour, long shadows, epic but slow." 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.

Move left shelves

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Move Left along bookstore shelves, warm tungsten practicals, shallow depth of field, slow glide.. 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 "Move Left along bookstore shelves, warm tungsten practicals, shallow depth of field, slow glide." 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 "Move Left along bookstore shelves, warm tungsten practicals, shallow depth of field, slow glide." 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.

Static lock portrait

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Static medium close up of subject facing soft wrap light, locked camera, calm expression, neutral backdrop.. 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 "Static medium close up of subject facing soft wrap light, locked camera, calm expression, neutral backdrop." 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 "Static medium close up of subject facing soft wrap light, locked camera, calm expression, neutral backdrop." 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.

Push in bread

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Slow push in on a tray of fresh bread, warm bakery practicals, soft steam, shallow depth of field.. 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 "Slow push in on a tray of fresh bread, warm bakery practicals, soft steam, shallow depth of field." 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 "Slow push in on a tray of fresh bread, warm bakery practicals, soft steam, shallow depth of field." 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.

Orbit bottle

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Orbit Left around a matte skincare bottle on wet stone, warm natural light, muted earth tones, product centered.. 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 "Orbit Left around a matte skincare bottle on wet stone, warm natural light, muted earth tones, product centered." 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 "Orbit Left around a matte skincare bottle on wet stone, warm natural light, muted earth tones, product centered." 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.

Crane down lobby

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Crane Down into a concrete lobby toward a single bench, cool ambient light, slow controlled move.. 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 "Crane Down into a concrete lobby toward a single bench, cool ambient light, slow controlled move." 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 "Crane Down into a concrete lobby toward a single bench, cool ambient light, slow controlled move." 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.

Pan neon street

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Pan Left along a wet neon street at night, soft rain, gentle speed, reflective asphalt.. 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 "Pan Left along a wet neon street at night, soft rain, gentle speed, reflective asphalt." 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 "Pan Left along a wet neon street at night, soft rain, gentle speed, reflective asphalt." 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.

Tracking runner

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Tracking side angle of a runner on a waterfront at dawn, cool soft light, steady pace match.. 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 "Tracking side angle of a runner on a waterfront at dawn, cool soft light, steady pace match." 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 "Tracking side angle of a runner on a waterfront at dawn, cool soft light, steady pace match." 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.

Push in cottage

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Slow push in toward a small cottage in the distance across a meadow, warm late light, gentle haze.. 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 "Slow push in toward a small cottage in the distance across a meadow, warm late light, gentle haze." 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 "Slow push in toward a small cottage in the distance across a meadow, warm late light, gentle haze." 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.

Pull out desk

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Pull Out from a notebook on a desk to reveal the full workspace, soft overhead daylight, calm mood.. 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 "Pull Out from a notebook on a desk to reveal the full workspace, soft overhead daylight, calm mood." 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 "Pull Out from a notebook on a desk to reveal the full workspace, soft overhead daylight, calm mood." 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.

Move up tools

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Move Up along a wall of hanging tools, soft side light, craft workshop atmosphere, slow rise.. 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 "Move Up along a wall of hanging tools, soft side light, craft workshop atmosphere, slow rise." 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 "Move Up along a wall of hanging tools, soft side light, craft workshop atmosphere, slow rise." 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.

Orbit chair

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Orbit around a wooden chair in a showroom, soft daylight, preserve wood grain, restrained speed.. 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 "Orbit around a wooden chair in a showroom, soft daylight, preserve wood grain, restrained speed." 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 "Orbit around a wooden chair in a showroom, soft daylight, preserve wood grain, restrained speed." 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 camera motion

One camera move per generation. Combining moves confuses results.

Prefer gentle and slow modifiers over vague cinematic motion.

Switch to static lock off if orbit distorts faces.

Lead with shot type before subject description.

Match camera vocabulary to your prompt library templates.

Use Camera Motion UI when you want a named control rather than hoping the text is parsed.

On web, type Camera to open movement styles. On iOS, use the prompt tray star controls per official help.

Split push in and pan into separate clips for editing together.

Fast moves on fine facial detail often fail. Slow down.

Product heroes often work with orbit or push in. Lifestyle scenes often work with tracking.

Keep subject centered language when orbiting products.

Budget credits for a motion failed pass. Camera is a common retry axis.

Prompting guidance that holds up in review

Name the move early: Push In, Pull Out, Pan Left, Orbit Right, Crane Up, Move Left.

Add a speed word every time: slow, gentle, steady, restrained.

State what stays centered when orbiting products.

Use static lock off as a first class option, not a failure state.

Keep lighting language stable while you test camera variants.

Limitations to respect

Official lists cover Pan, Orbit, Crane, Move, Push In, and Pull Out. Confirm your live build for exact labels.

Multiple moves in one prompt remain a common failure mode.

Aggressive orbits on thin products can warp edges.

Avoid adding a second move during Extend.

Field tips from real boards

Document which moves succeed for each brand template.

Review motion on a large preview. Tiny players hide jitter.

If UI and text conflict, simplify to one instruction source.

Confirm available moves in your current Dream Machine build rather than assuming older lists.

Name one move and one speed word before you describe the subject. Ambiguous motion is the common failure.

Static lock off is a production choice, not a retreat. Use it when faces or thin products warp.

Split push in and pan into two clips when the edit needs both. Do not force them into one generation.

Orbit language should state what stays centered, especially for product heroes.

Fast moves punish fine facial detail. Slow and steady usually wins review.

Use the Camera Motion UI when you want a named control instead of hoping text alone is parsed.

Keep lighting constants while you A B camera variants so motion is the only changing axis.

Review camera jitter on a large preview. Phone sized players hide micro shake.

If UI controls and prompt text disagree, remove one source of instruction and regenerate.

Name one move and one speed word before you describe the subject.

Static lock off is a production choice when faces or thin products warp.

Split push in and pan into two clips when the edit needs both.

Orbit language should state what stays centered for product heroes.

Fast moves punish fine facial detail. Slow and steady usually wins.

Use Camera Motion UI when you want a named control.

Keep lighting constants while you A B camera variants.

Review camera jitter on a large preview.

If UI controls and prompt text disagree, remove one instruction source.

Pan and orbit are different jobs. Pan reveals space. Orbit reveals form.

Crane moves need a clear vertical story, such as from sign to ridge, not random lift.

Push In intensifies. Pull Out contextualizes. Pick the emotional direction on purpose.

Move Left and Move Right along shelves or walls read cleaner than diagonal invent moves.

On web, type Camera to open named moves. On iOS, use the prompt tray controls per official help.

Speed words change outcomes more than people expect. Gentle often beats dramatic.

Product orbits fail when the subject is not centered in the still or prompt.

If a face warps on orbit, regenerate with static lock off and animate only the subject.

Build a camera cheat sheet for the brand with one approved move per template.

Common mistakes

Slow push in then pan left then crane up in one generation
Fast camera moves on fine facial detail
No shot type named before subject description
Orbiting thin products too aggressively
Adding new moves during Extend
Ignoring static lock off as a valid choice

Related Luma articles: /blog/how-to-use-luma-dream-machine-for-text-to-video, /blog/how-to-use-keyframes-and-loops-in-luma, /blog/how-to-build-campaigns-and-reusables-in-luma. Return to /explore/luma for the broader guide set.