> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.ltx.io/open-source-model/vfx-post-production/layout-to-render/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.ltx.io/_mcp/server.

# Layout to Render

> Turn a 3D viewport animation or blocky playblast into a finished shot with LTX-2.5, using an art-directed first frame to define its materials, lighting, and palette.

Layout to Render turns a 3D viewport animation into a finished shot. The layout can be a detailed clay render or a blocky playblast of simple shapes from Blender, Unreal, or a similar tool. It guides the camera, motion, framing, and placement of objects, while an art-directed first frame and a short prompt define materials, lighting, color, and overall appearance.

The adapter is designed for camera-accurate look development and shot iteration. It keeps the camera path and object placement aligned to the layout, including the movement of simple blocking shapes. Because the result is generative, review that alignment before using it downstream.

This workflow is distinct from Motion Transfer. It uses the layout video itself as an IC-LoRA guide; it does not extract motion from one subject and apply it to another.

## Supported surfaces

| Surface | Entry point                                                | Output audio                                                         |
| ------- | ---------------------------------------------------------- | -------------------------------------------------------------------- |
| ComfyUI | `LTX-2.5_ICLoRA_Layout_To_Render_Two_Stage_Distilled.json` | Silent; the graph does not pass through source audio.                |
| Python  | `python -m ltx_pipelines.ic_lora` with `--stage-2-ic-lora` | Generated with the output video; source audio is not passed through. |

## Prerequisites

* A current ComfyUI installation with the LTX video nodes required by the workflow, or `ltx-pipelines` and its dependencies for Python.
* The LTX-2.5 distilled model stack and 2x latent spatial upscaler required by your chosen surface.
* The Layout to Render IC-LoRA.

## Model files

**Model card:** [LTX-2.5 22B IC-LoRA Layout to Render](https://huggingface.co/Lightricks/LTX-2.5-22b-IC-LoRA-Layout-To-Render)

For ComfyUI, install these version-matched files:

| File                                                      | Role                                                                         | Placement                               |
| --------------------------------------------------------- | ---------------------------------------------------------------------------- | --------------------------------------- |
| `ltx-2.5-22b-distilled-transformer-bf16.safetensors`      | LTX-2.5 distilled transformer                                                | `ComfyUI/models/diffusion_models/`      |
| `gemma4-12b-with-proj-ltx-2.5-bf16.safetensors`           | LTX-2.5 text encoder for local prompt encoding                               | `ComfyUI/models/text_encoders/`         |
| `ltx-2.5-video-vae-bf16.safetensors`                      | Video VAE used to encode the references and decode the result                | `ComfyUI/models/vae/`                   |
| `ltx-2.5-audio-vae-bf16.safetensors`                      | Audio VAE loaded by the graph, although this workflow produces silent output | `ComfyUI/models/vae/`                   |
| `ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors` | 2x latent spatial upscaler used before stage 2                               | `ComfyUI/models/latent_upscale_models/` |
| `ltx-2.5-22b-ic-lora-layout-to-render-1.0.safetensors`    | Layout to Render IC-LoRA; the model card specifies strength `1.0`            | `ComfyUI/models/loras/`                 |

For Python, provide either the monolithic distilled checkpoint and Gemma model root or the equivalent split model components supported by `ltx-pipelines`. The native pipeline also requires the spatial upsampler and Layout to Render IC-LoRA paths.

## Inputs

| Input                    | Requirement                             | Purpose                                                                                                                                                                   |
| ------------------------ | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Layout video             | Required                                | Guides camera movement, framing, object placement, and motion. Use a clay viewport render or a blocky playblast; a detailed render is not required.                       |
| Art-directed first frame | Required                                | Supplies the intended palette, lighting, materials, and detail. Create it from the first frame of the layout so its geometry matches; do not use the raw gray clay frame. |
| Additional keyframes     | Optional                                | Add mid-shot or final images when the visual treatment needs stronger guidance through the shot.                                                                          |
| Positive prompt          | Optional in ComfyUI; required in Python | Describes the intended rendered result.                                                                                                                                   |
| Negative prompt          | Optional in ComfyUI                     | Describes content or qualities to avoid. The native IC-LoRA command does not expose a negative-prompt option.                                                             |
| LTX API key              | Optional in ComfyUI                     | Lets the ComfyUI graph encode prompts through the API instead of the local text encoder.                                                                                  |

Both the layout video and art-directed first frame are required. The ComfyUI graph labels the first-frame input **Load reference image (Look Still)** and connects both inputs directly with no bypass. In Python, you set output dimensions, frame count, and frame rate explicitly.

The model card recommends a 24 fps layout clip and identifies 1920×1088 as a known-good output size. Width and height must be divisible by 64. The workflow snaps the source length down to a supported `8k+1` frame count; for example, a 72-frame clip becomes 65 frames.

> **Note**
>
> Use one or two sentences that describe the finished shot and match the art-directed first frame. Do not describe the layout source — avoid words like "clay," "3D," or "Unreal," which push the output toward the blockout look instead of the finished render.

## Run in ComfyUI

1. Load `LTX-2.5_ICLoRA_Layout_To_Render_Two_Stage_Distilled.json` in ComfyUI.
2. In **Source video**, select the layout or clay-render clip. Its dimensions, frame rate, and valid frame count drive the generated clip.
3. In **Load reference image (Look Still)**, select the art-directed image created from the layout's first frame.
4. Enter positive and negative prompts if needed. Add an LTX API key only if you want to offload prompt encoding.
5. Confirm that the required model files are installed. Keep the model and generation settings supplied with the workflow unless the model card documents a supported alternative.
6. Choose a seed and review the decode tile and overlap settings for the available VRAM.
7. Run the workflow and review the saved video for composition, camera motion, geometry drift, and temporal consistency.

## Run with Python

Use the same references with the native IC-LoRA pipeline: pass the layout video as video conditioning and the art-directed first frame as an image at temporal position `-1`. The `--stage-2-ic-lora` option keeps the Layout to Render conditioning active during the high-resolution stage.

```bash
python -m ltx_pipelines.ic_lora \
    --distilled-checkpoint-path /path/to/distilled-checkpoint.safetensors \
    --spatial-upsampler-path /path/to/spatial-upscaler.safetensors \
    --gemma-root /path/to/gemma \
    --lora /path/to/ltx-2.5-22b-ic-lora-layout-to-render-1.0.safetensors \
    --video-conditioning /path/to/layout.mp4 1.0 \
    --stage-2-ic-lora \
    --image /path/to/art-directed-first-frame.png -1 1.0 \
    --prompt "A finished cinematic render with the materials, lighting, and palette of the reference image." \
    --height 1088 --width 1920 \
    --num-frames 73 --frame-rate 24 \
    --output-path layout-to-render.mp4
```

This example uses the model card's known-good output size of 1920×1088. Keep width and height divisible by 64. Repeat `--image PATH FRAME_INDEX STRENGTH` to add mid-shot or final keyframes; the normal recipe begins with the art-directed first frame at position `-1`.

The example uses the monolithic-checkpoint form. If your installation uses split model files, replace the distilled checkpoint and Gemma arguments with the split-model arguments supported by your installed version.

## How the conditioning works

On both surfaces, the layout clip is VAE-encoded and attached as the IC-LoRA guide. The art-directed image is encoded separately at temporal position `-1`, establishing the first frame's visual treatment. Additional keyframes can reinforce that treatment later in the shot.

The ComfyUI graph uses a two-stage distilled process:

1. A low-resolution composition pass uses the Layout to Render IC-LoRA and both references.
2. The graph removes the guide tokens, performs a 2x latent spatial upscale, and starts a high-resolution refinement pass.
3. Both references are encoded again at the new resolution and reapplied before the second pass.
4. The second-stage guide tokens are removed before the final video is decoded.

Guide positions are recorded against the latent resolution where they were added. Stage 1 removes its guides before the 2× latent upscale. Stage 2 encodes and attaches both references again at the new resolution, then removes those guides before decode.

## ComfyUI decode memory

Use the tiled VAE decode controls in the workflow to fit the available VRAM. Fewer, larger tiles decode faster but need more VRAM; smaller tiles lower peak memory. Keep the values supplied by the workflow unless you need to tune decode memory for your hardware.

> **Note**
>
> This tiling manages VAE decode memory only. It is not the separate Native Resolution generation workflow.

## Output and audio

The supplied workflow uses a lower-resolution composition pass, then a 2× latent upscale and a shorter full-resolution refinement pass. The source video's frame rate is retained, subject to the supported frame-count rounding described above.

The ComfyUI graph creates a silent audio latent and does not pass through or mux the source soundtrack. The native pipeline generates audio with its output video, but it does not preserve the source soundtrack. Add or replace audio in a downstream editor when you need source-synchronous sound.

## Limitations

* Layout to Render is designed to preserve camera motion and object placement, but it remains generative. Review alignment, geometry, and temporal consistency before using the result downstream.
* Both the layout video and art-directed first frame are required.
* Neither surface preserves source audio. ComfyUI produces silent video; Python generates new audio with the result.

## Related pages

* [Using ComfyUI with LTX](/open-source-model/integration-tools/comfy-ui)
* [PyTorch API](/open-source-model/integration-tools/pytorch-api)
* [LTX ComfyUI Nodes](/open-source-model/integration-tools/ltx-comfy-ui-nodes)
* [Prompting guide](/open-source-model/usage-guides/prompting-guide)
* [Workflow & Asset Compatibility](/open-source-model/reference/workflow-asset-compatibility)

> Turn a 3D viewport animation or blocky playblast into a finished shot with LTX-2.5, using an art-directed first frame to define its materials, lighting, and palette.