September 1, 2026AIExplore

How to Use Luma Dream Machine for Text-to-Video

Write structured Dream Machine prompts with subject, action, setting, one camera move, lighting, and style, then iterate toward usable clips.

Luma

Luma Dream Machine turns natural language into short video. Official best practices treat prompts like a conversation in detailed language. Structure each shot around subject, action, setting, one camera move, lighting, and style. Front load the most important details. Credits vary by model, resolution, and duration. Confirm live plans on lumalabs.ai/pricing. Start at /explore/luma.

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

When this workflow is the right job

Use text to video when you do not have an approved still yet, or when you want to invent a scene from a written brief. Prefer image to video when a product still is already locked. Prefer Modify when a nearby clip already exists.

Step by step workflow

1. Draft a six part brief

Name subject, action, setting, camera, lighting, and style before you open Dream Machine.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Subject: ceramic coffee mug on wood table Action: steam rising slowly Setting: morning kitchen Camera: slow push in Lighting: window light from left Style: 35mm film, cozy grade. 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 "Subject: ceramic coffee mug on wood table Action: steam rising slowly Setting: morning kitchen Camera: slow push in Lighting: window light from left Style: 35mm film, cozy grade" 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 "Subject: ceramic coffee mug on wood table Action: steam rising slowly Setting: morning kitchen Camera: slow push in Lighting: window light from left Style: 35mm film, cozy grade" 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. Write one natural language prompt

Convert the brief into sentences. Keep a single camera move. Front load shot type and subject.

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 from hot coffee, morning sunlight through a window from the left, warm golden lighting, shallow depth of field, soft background, cozy morning atmosphere, shot on 35mm film.. 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 from hot coffee, morning sunlight through a window from the left, warm golden lighting, shallow depth of field, soft background, cozy morning atmosphere, shot on 35mm film." 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 from hot coffee, morning sunlight through a window from the left, warm golden lighting, shallow depth of field, soft background, cozy morning atmosphere, shot on 35mm film." 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 and review

Check subject clarity, motion credibility, and whether lighting matches the brief. Note what failed without rewriting everything.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Review checklist [ ] Subject readable in first second [ ] Only one camera move [ ] Lighting direction matches brief [ ] No unwanted new objects. 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 "Review checklist [ ] Subject readable in first second [ ] Only one camera move [ ] Lighting direction matches brief [ ] No unwanted new objects" 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 "Review checklist [ ] Subject readable in first second [ ] Only one camera move [ ] Lighting direction matches brief [ ] No unwanted new objects" 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. Refine narrowly

Change one axis: camera, lighting, or style. Or use Modify when the clip is close.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Keep subject and setting. Change camera only: static lock off instead of push in. Keep warm morning 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 "Keep subject and setting. Change camera only: static lock off instead of push in. Keep warm morning 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 "Keep subject and setting. Change camera only: static lock off instead of push in. Keep warm morning 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.

Practical text to video prompts

Cafe steam 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, shallow depth of field, cozy atmosphere, shot on 35mm film.. 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, shallow depth of field, cozy atmosphere, shot on 35mm film." 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, shallow depth of field, cozy atmosphere, shot on 35mm film." 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.

Harbor blue hour

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Wide establishing shot of a quiet harbor at blue hour, slow push in toward a docked sailboat, soft overcast light, muted blues and greys, cinematic still 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 "Wide establishing shot of a quiet harbor at blue hour, slow push in toward a docked sailboat, soft overcast light, muted blues and greys, cinematic still 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 "Wide establishing shot of a quiet harbor at blue hour, slow push in toward a docked sailboat, soft overcast light, muted blues and greys, cinematic still 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.

Chef plating

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.

Sneaker product hero

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 matte black sneaker on concrete, slow steady move, soft daylight, shallow depth of field, product stays centered, clean commercial look.. 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 matte black sneaker on concrete, slow steady move, soft daylight, shallow depth of field, product stays centered, clean commercial look." 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 matte black sneaker on concrete, slow steady move, soft daylight, shallow depth of field, product stays centered, clean commercial look." 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.

Rainy street night

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 shot of neon reflections on wet asphalt at night, gentle rain falling, soft bokeh lights in background, nocturnal city mood, subtle handheld micro movement.. 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 shot of neon reflections on wet asphalt at night, gentle rain falling, soft bokeh lights in background, nocturnal city mood, subtle handheld micro movement." 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 shot of neon reflections on wet asphalt at night, gentle rain falling, soft bokeh lights in background, nocturnal city mood, subtle handheld micro movement." 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.

Forest path dawn

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Slow tracking shot along a forest path at dawn, light fog between trees, camera moves forward gently, cool soft light, naturalistic grade.. 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 tracking shot along a forest path at dawn, light fog between trees, camera moves forward gently, cool soft light, naturalistic grade." 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 tracking shot along a forest path at dawn, light fog between trees, camera moves forward gently, cool soft light, naturalistic grade." 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.

Desk workspace

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Top down static shot of a tidy desk with notebook and pen, soft overhead daylight, paper texture visible, calm productivity mood, no camera 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 "Top down static shot of a tidy desk with notebook and pen, soft overhead daylight, paper texture visible, calm productivity mood, no camera 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 "Top down static shot of a tidy desk with notebook and pen, soft overhead daylight, paper texture visible, calm productivity mood, no camera 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.

Skincare bottle

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Wide shot of a matte skincare bottle on wet stone, handheld with gentle movement, warm natural light, muted earth tones, shot on 35mm film.. 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 "Wide shot of a matte skincare bottle on wet stone, handheld with gentle movement, warm natural light, muted earth tones, shot on 35mm film." 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 "Wide shot of a matte skincare bottle on wet stone, handheld with gentle movement, warm natural light, muted earth tones, shot on 35mm film." 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.

Train window

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Medium shot from inside a train looking out a window at passing countryside, soft motion blur outside, warm afternoon light, quiet travel mood, static interior framing.. 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 shot from inside a train looking out a window at passing countryside, soft motion blur outside, warm afternoon light, quiet travel mood, static interior framing." 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 shot from inside a train looking out a window at passing countryside, soft motion blur outside, warm afternoon light, quiet travel mood, static interior framing." 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.

Bookstore aisle

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 down a bookstore aisle, warm tungsten practicals, dust motes in light beams, shallow depth of field, cozy literary atmosphere.. 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 down a bookstore aisle, warm tungsten practicals, dust motes in light beams, shallow depth of field, cozy literary atmosphere." 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 down a bookstore aisle, warm tungsten practicals, dust motes in light beams, shallow depth of field, cozy literary atmosphere." 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.

Mountain ridge

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Wide landscape of a mountain ridge at golden hour, slow crane up, long shadows, crisp air haze, epic but restrained 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 "Wide landscape of a mountain ridge at golden hour, slow crane up, long shadows, crisp air haze, epic but restrained 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 "Wide landscape of a mountain ridge at golden hour, slow crane up, long shadows, crisp air haze, epic but restrained 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.

Lab glassware

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Static close up of clear glassware on a lab bench, soft cool key light from left, subtle reflection highlights, clean scientific aesthetic.. 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 close up of clear glassware on a lab bench, soft cool key light from left, subtle reflection highlights, clean scientific aesthetic." 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 close up of clear glassware on a lab bench, soft cool key light from left, subtle reflection highlights, clean scientific aesthetic." 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.

Bicycle cafe

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Medium shot of a bicycle leaning on a cafe wall in afternoon shade, slight leaf movement, soft diffuse light, quiet street mood, locked 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 "Medium shot of a bicycle leaning on a cafe wall in afternoon shade, slight leaf movement, soft diffuse light, quiet street mood, locked 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 "Medium shot of a bicycle leaning on a cafe wall in afternoon shade, slight leaf movement, soft diffuse light, quiet street mood, locked 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.

Bakery tray

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 in a bakery, warm practical lights, soft steam, shallow depth of field, inviting morning atmosphere.. 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 in a bakery, warm practical lights, soft steam, shallow depth of field, inviting morning atmosphere." 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 in a bakery, warm practical lights, soft steam, shallow depth of field, inviting morning atmosphere." 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.

Studio portrait setup

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 shot of an empty portrait set with softbox and stool, soft wrap light, muted grey backdrop, calm prep mood before talent arrives.. 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 shot of an empty portrait set with softbox and stool, soft wrap light, muted grey backdrop, calm prep mood before talent arrives." 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 shot of an empty portrait set with softbox and stool, soft wrap light, muted grey backdrop, calm prep mood before talent arrives." 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.

Rooftop dusk

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Slow pan right across a rooftop garden at dusk, city lights beginning, cool blue ambient with warm window spill, gentle evening 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 "Slow pan right across a rooftop garden at dusk, city lights beginning, cool blue ambient with warm window spill, gentle evening 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 "Slow pan right across a rooftop garden at dusk, city lights beginning, cool blue ambient with warm window spill, gentle evening 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.

Workshop tools

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Close tracking shot along a row of hand tools on a wooden bench, soft side light, dust and wood grain visible, craft workshop atmosphere.. 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 "Close tracking shot along a row of hand tools on a wooden bench, soft side light, dust and wood grain visible, craft workshop atmosphere." 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 "Close tracking shot along a row of hand tools on a wooden bench, soft side light, dust and wood grain visible, craft workshop atmosphere." 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 text to video results

Front load shot type, subject, and camera early so they are not diluted by later style words.

Use only one camera move per generation. Split push in and pan into separate clips you cut together later.

Anchor style with film stock, lighting recipes, or color language rather than vague mood words alone.

You can request on screen text per current official best practices. Always review readability and composite critical brand marks in post when precision matters.

Explore draft or lower cost variants before a final higher resolution render. Confirm credit costs by model and resolution on the pricing page.

Keep related shots on one board when building a sequence so continuity stays easier.

When hands or faces fail, tighten framing or regenerate variants instead of stacking conflicting descriptors.

If the model invents objects, list what must not appear rather than only what you want.

Replace keyword dumps with active verbs and clear setting details.

Match lighting language across a campaign so cuts feel like one world.

Treat failed clips as data. Note which axis failed: camera, subject, or lighting, then change that axis only.

For product work, prefer image to video once a still is approved. Text to video is better for inventing worlds.

Prompting guidance that holds up in review

Write prompts like camera notes: who or what is in frame, what moves, where the light comes from, and how the camera behaves.

Put the most important creative decisions in the first sentence. Later clauses should support, not compete.

Name materials and scale when products matter. Ceramic mug and brushed steel read differently than generic cup.

Use static camera language when motion causes artifacts. Still frames with subject motion can be safer.

Build a personal library of prompts that repeatedly succeed and swap subjects while locking camera and light.

Limitations to respect

Credit cost depends on model, resolution, and duration. Official pricing lists Ray3.2, Ray3.14, and partner models with different costs. Do not assume a flat rate.

Readable on screen text varies. Treat generated type as a draft unless you have verified every frame.

Complex multi move camera plans belong in the edit, not in a single generation.

Confirm commercial use terms for your plan before client delivery. Plus lists commercial use on the official pricing page.

Field tips from real boards

Avoid shipping the first generation as final. Budget at least one refinement pass in your credit plan.

When storytelling across shots, write each clip as a self contained brief with shared lighting constants.

If a prompt grows longer than a short paragraph, split style notes into a second refine pass.

Track which models your team actually uses so credit forecasts stay honest.

Score each take on subject clarity in the first second before you judge style.

If the prompt reads like a tag cloud, rewrite it as camera notes with verbs.

Keep a swipe file of lighting recipes that repeatedly survive client review.

When on screen text appears, screenshot every frame that shows glyphs before approval.

Common mistakes

Keyword dumps without action or camera language
Multiple camera moves in one prompt
Vague mood words with no subject detail
Shipping unreviewed on screen text as final brand type
Rewriting everything when one axis failed
Ignoring credit cost differences across models and resolutions

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