You can deploy this model and start earning money today!

cre-ai-tiv-company/
LTX-Video-MLX-Blueprint

Name: LTX-Video-MLX-Blueprint
Availability: InStock

Views

No views yet

LTX-2.3 Video, Image & Audio on Apple Silicon (MLX) — Claude Code Blueprint

What this is: A reproducible blueprint for Claude Code. Give this file to Claude Code and say: "Here's a blueprint for running LTX-2.3 locally on Mac with MLX. Build me this setup."

What it builds: A fully local creative studio — video, image, and audio generation — using Lightricks' LTX-2.3 (22B) on Apple Silicon via MLX, with Z-Image-Turbo for images, all routed through a FastAPI proxy compatible with the official LTX Desktop Electron app.

Requirements: Mac with Apple Silicon (M1 Pro/Max or better, 64GB+ RAM recommended), Python 3.11+, uv package manager

Architecture Overview

LTX Desktop (Electron App)          Your own PySide6 App
    ├── Video Gen ──┐                       |
    ├── Image Gen ──┤                       |
    └── Audio Gen ──┤                       |
                    v                       v
          FastAPI Proxy Server (port 8080)
          mimics api.ltx.video + fal.run
                    |
          ┌─────────┴──────────┐
          v                    v
    mlx-video Engine     zimg Server (port 8001)
    LTX-2.3 pipeline     Z-Image-Turbo (PyTorch MPS)
    Video + Audio              Images
          |                    |
          v                    v
    Apple Silicon GPU (Metal / MPS)

Port Layout:

Port	Service
8000	LTX Desktop Backend (Electron app's own Python backend)
8001	zimg (Z-Image-Turbo, PyTorch MPS)
8080	FastAPI Proxy (routes video→MLX, image→zimg, audio→MLX)

Four components:

mlx-video — MLX-native video + audio generation engine (fork of Blaizzy/mlx-video)
zimg — Z-Image-Turbo image generation server (PyTorch MPS)
FastAPI Proxy — Translates LTX/FAL cloud API calls to local generation
LTX Desktop — Lightricks' Electron app, patched to hit localhost instead of cloud APIs

Part 1: mlx-video Engine Setup

1.1 Clone and install

bash

cd /your/workspace
git clone https://github.com/Blaizzy/mlx-video.git
cd mlx-video
uv venv && source .venv/bin/activate
uv pip install -e ".[dev]"

1.2 Download LTX-2.3 model weights

The model is ~44GB. Download from HuggingFace:

bash

# Option A: HuggingFace CLI
huggingface-cli download Lightricks/LTX-2.3

# Option B: Manual download to HF cache
mkdir -p ~/.cache/huggingface/hub/models--Lightricks--LTX-2.3/snapshots/manual/
# Download these files into that directory:
# - ltx-2.3-22b-distilled.safetensors (43GB)
# - ltx-2.3-spatial-upscaler-x2-1.0.safetensors (950MB)

1.3 Critical fixes for LTX-2.3 on MLX

The base mlx-video repo (as of March 2026) has several bugs when running LTX-2.3. These are the fixes that took us from "pure noise output" to working video generation.

Fix 1: Transformer AdaLN Parameter Index Swap (CRITICAL)

File: mlx_video/models/ltx/transformer.py Problem: The AdaLN (Adaptive Layer Normalization) parameter indices for cross-attention and MLP are swapped.

The LTX-2.3 scale_shift_table has 9 parameters per block. The correct ordering (from the PyTorch reference) is:

[0:3] — Self-attention (shift, scale, gate)
[3:6] — MLP (shift, scale, gate)
[6:9] — Cross-attention (shift, scale, gate)

The bug: Cross-attention reads from slice(3, 6) (MLP's params) and MLP reads from slice(6, 9) (cross-attention's params). This causes complete feature corruption — the model outputs noise.

Fix: In BasicAVTransformerBlock.__call__():

Cross-attention section (~line 304): Change slice(3, 6) to slice(6, 9)

python

# BEFORE (wrong):
vshift_ca, vscale_ca, vgate_ca = self.get_ada_values(
    self.scale_shift_table, vx.shape[0], video.timesteps, slice(3, 6)
)
# AFTER (correct):
vshift_ca, vscale_ca, vgate_ca = self.get_ada_values(
    self.scale_shift_table, vx.shape[0], video.timesteps, slice(6, 9)
)

MLP section (~line 423): Change conditional mlp_start = 6 if cross_attention_adaln else 3 to always use slice(3, 6)

python

# BEFORE (wrong):
mlp_start = 6 if self.cross_attention_adaln else 3
vshift_mlp, vscale_mlp, vgate_mlp = self.get_ada_values(
    self.scale_shift_table, vx.shape[0], video.timesteps, slice(mlp_start, mlp_start + 3)
)
# AFTER (correct):
vshift_mlp, vscale_mlp, vgate_mlp = self.get_ada_values(
    self.scale_shift_table, vx.shape[0], video.timesteps, slice(3, 6)
)

Apply the same fix to the audio path — same indices for audio_scale_shift_table.

Fix 2: Text Encoder V2 Auto-Detection (CRITICAL)

File: mlx_video/models/ltx/text_encoder.py Problem: The text encoder initializes with LTX-2.0 dimensions (hidden_dim=3840, 2 connector layers) but LTX-2.3 uses different dimensions (hidden_dim=4096, 8 connector layers). The weight loading glob also doesn't match LTX-2.3 filenames.

Fix: Add V2 auto-detection in LTX2TextEncoder:

Expand the weight file glob to match ltx-2*.safetensors (not just ltx-2-19*.safetensors)
Add _detect_and_reinit_for_v2() method that:
- Detects V2 by checking for text_embedding_projection.video_aggregate_embed.weight key
- Reads hidden_dim from weight shape (4096 for V2)
- Counts connector layers from weight keys (8 for V2)
- Reinitializes all components with correct dimensions
Handle V2 weight key differences:
- V2 uses video_aggregate_embed (with bias) vs V1's aggregate_embed (without bias)
- V2 has separate audio_aggregate_embed and audio_feature_extractor

Key dimensions for LTX-2.3:

hidden_dim = 4096 (V1: 3840)
audio_dim = 2048
connector_layers = 8 (V1: 2)
num_heads = 32 (= 4096/128)
feature_extractor input_dim = 4096 * 49 = 200704

Fix 3: ConnectorAttention Gated Attention (IMPORTANT)

File: mlx_video/models/ltx/text_encoder.py Problem: The ConnectorAttention class is missing to_gate_logits — a per-head gating mechanism used in LTX-2.3. This means 32 weight tensors (2 per connector block × 16 blocks) are silently dropped during weight loading.

Fix: Add gated attention to ConnectorAttention:

python

class ConnectorAttention(nn.Module):
    def __init__(self, dim, num_heads, head_dim, apply_gated_attention=False):
        # ... existing init ...
        if apply_gated_attention:
            self.to_gate_logits = nn.Linear(dim, num_heads, bias=True)

    def __call__(self, x, ...):
        # ... existing attention computation ...
        out = self.to_out(out)

        if self.apply_gated_attention:
            gate = 2.0 * mx.sigmoid(self.to_gate_logits(x))
            gate = mx.expand_dims(gate, axis=-1)  # (B, seq, heads, 1)
            out = mx.reshape(out, (batch_size, seq_len, self.num_heads, self.head_dim))
            out = out * gate
            out = mx.reshape(out, (batch_size, seq_len, -1))
        return out

Pass apply_gated_attention=True through ConnectorTransformerBlock → Embeddings1DConnector → _init_components() when V2 is detected.

Fix 4: Resolution Divisibility (MINOR)

Problem: Some resolution presets (e.g., 960x544) have dimensions not divisible by 64, which MLX requires.

Fix: Add a _round_to_64() helper and apply it to all resolutions:

python

def _round_to_64(v: int) -> int:
    return ((v + 32) // 64) * 64

Key mappings: 544 → 576, 720 → 704, 1080 → 1088

Part 2: FastAPI Proxy Server

Create a proxy server that mimics api.ltx.video endpoints so the LTX Desktop Electron app works with local generation.

2.1 Required endpoints

GET  /health                    → {"status": "ok", "mode": "local_mlx", "model": "Lightricks/LTX-2.3"}
POST /v1/text-to-video          → prompt, resolution, num_frames, fps, seed, generate_audio → MP4 bytes
POST /v1/image-to-video         → image + prompt → MP4 bytes
POST /v1/audio-to-video         → audio file + image + prompt → generates video, muxes with uploaded audio
POST /v1/upload                 → image/audio file upload → returns URL for I2V/A2V
POST /fal-ai/z-image/turbo      → FAL-compatible image generation → proxied to zimg:8001

2.2 Key proxy logic

python

# Resolution mapping (API string → pixel dimensions)
RESOLUTION_MAP = {
    "960x544": (960, 576),    # 544→576 (divisible by 64)
    "1280x720": (1280, 704),  # 720→704
    "1920x1080": (1920, 1088), # 1080→1088
    "512x512": (512, 512),
}

# The proxy converts API resolution strings like "540p" + "16:9" → "960x576"
# Then calls mlx_video.generate.generate_video() directly

2.3 Environment variables

bash

LTX_MODEL_REPO=Lightricks/LTX-2.3  # Which model to load
LTX_PROXY_HOST=127.0.0.1           # Listen address
LTX_PROXY_PORT=8080                 # Listen port
ZIMG_BASE_URL=http://localhost:8001 # zimg server for image generation

2.4 LaunchAgent (auto-start on login)

Create ~/Library/LaunchAgents/com.ltx2.proxy.plist:

xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.ltx2.proxy</string>
    <key>ProgramArguments</key>
    <array>
        <string>/path/to/uv</string>
        <string>run</string>
        <string>python</string>
        <string>-m</string>
        <string>ltx2app.proxy.server</string>
    </array>
    <key>WorkingDirectory</key>
    <string>/path/to/LTX2_App</string>
    <key>EnvironmentVariables</key>
    <dict>
        <key>LTX_MODEL_REPO</key>
        <string>Lightricks/LTX-2.3</string>
        <key>ZIMG_BASE_URL</key>
        <string>http://localhost:8001</string>
    </dict>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
</dict>
</plist>

Part 3: Patching LTX Desktop (Electron App)

3.1 Redirect API calls to localhost

The LTX Desktop app calls api.ltx.video (video) and fal.run (images). Patch both to redirect to localhost:8080:

Video API: /Applications/LTX Desktop.app/Contents/Resources/backend/handlers/video_generation_handler.py

Find api.ltx.video and replace with localhost:8080

Image API: Same file or image_generation_handler.py

Find fal.run and replace with localhost:8080

A patch_ltx_desktop.py script can automate both patches.

3.2 Unlock all resolutions in the frontend

The frontend JS is packed in app.asar. Unpack, patch, repack:

bash

# Unpack
npx asar extract "/Applications/LTX Desktop.app/Contents/Resources/app.asar" /tmp/ltx_asar

# Find the main JS bundle
# Look in /tmp/ltx_asar/dist/assets/index-*.js

# Patch resolution filters — find patterns like:
#   T=v?d?["1080p"]:[...gm]:["540p","720p","1080p"]
# Replace with:
#   T=[...gm]
# This removes conditional filtering and shows all resolutions everywhere

# Repack
npx asar pack /tmp/ltx_asar /tmp/app_patched.asar

# Install (may need to copy app to /tmp first due to SIP)
cp -R "/Applications/LTX Desktop.app" /tmp/LTXPatched.app
cp /tmp/app_patched.asar /tmp/LTXPatched.app/Contents/Resources/app.asar
rm -rf "/Applications/LTX Desktop.app"
mv /tmp/LTXPatched.app "/Applications/LTX Desktop.app"
codesign --force --deep --sign - "/Applications/LTX Desktop.app"
xattr -cr "/Applications/LTX Desktop.app"

Part 4: LTX-2.3 Technical Reference

Key technical details for anyone implementing or debugging the LTX-2.3 pipeline:

Two-Stage Distilled Generation

LTX-2.3 uses a two-stage pipeline:

Stage 1: Generate at half resolution (8 denoising steps)
Spatial upsample: 2x latent upsampling via dedicated upsampler network
Stage 2: Refine at full resolution (3 denoising steps)

Sigma Schedules (Distilled)

python

STAGE_1_SIGMAS = [1.0, 0.99375, 0.9875, 0.98125, 0.975, 0.909375, 0.725, 0.421875, 0.0]
STAGE_2_SIGMAS = [0.909375, 0.725, 0.421875, 0.0]

Velocity Prediction

python

# Denoised prediction from velocity
x0 = x_t - sigma * velocity

# Euler step
x_next = x0 + sigma_next * (x_t - x0) / sigma

VAE Normalization

python

# Denormalize before upsampling
latent = latent * latent_std + latent_mean

# Renormalize after upsampling
latent = (latent - latent_mean) / latent_std

LTX-2.3 vs LTX-2.0 Key Differences

Feature	LTX-2.0	LTX-2.3
Parameters	19B	22B
hidden_dim	3840	4096
Connector layers	2	8
Gated attention	No	Yes (`2*sigmoid(gate)`)
AdaLN params	6 (self-attn + MLP)	9 (+ cross-attn)
Prompt AdaLN	No	Yes (2 params: shift+scale)
caption_proj_before_connector	No	Yes
VAE timestep_conditioning	Yes	No
VAE decoder blocks	Variable	9 (mixed strides)

MLX-Specific Considerations

Conv3d format: MLX uses channels-last (B, D, H, W, C), PyTorch uses (B, C, D, H, W) — transpose at boundaries
Conv3d weight format: MLX (O, D, H, W, I) vs PyTorch (O, I, D, H, W) — transpose during weight loading
Resolution constraint: All spatial dimensions must be divisible by 64
Memory: 512x512 25 frames needs ~32GB, 1080p needs 64GB+
Chunked Conv3d: MLX conv3d can fail with large tensors (~33+ frames at 192x192), use temporal chunking

Part 5: Image Generation (Z-Image-Turbo)

LTX Desktop uses FAL's Z-Image API for image generation. We intercept those calls and route them to a local zimg server running Z-Image-Turbo on PyTorch MPS.

5.1 Install zimg

uv tool install zimg

5.2 How the image proxy works

The proxy intercepts FAL API calls from LTX Desktop and translates them:

LTX Desktop → POST /fal-ai/z-image/turbo (FAL format)
    → Proxy translates to zimg format
    → POST http://localhost:8001/generate
    → zimg generates image via PyTorch MPS
    → Proxy translates response back to FAL format
    → Returns to LTX Desktop

Key translation details:

FAL sends image_size: {"width": W, "height": H} → zimg expects width and height as top-level params
FAL expects images: [{"url": "...", "content_type": "image/png"}] → zimg returns {"image_url": "..."}
Proxy saves images persistently and serves them via /images/{filename} endpoint

5.3 Patch LTX Desktop for local image generation

The patch_ltx_desktop.py script patches both API redirects:

Video API: api.ltx.video → localhost:8080
Image API: fal.run → localhost:8080

In ~/Library/Application Support/LTXDesktop/settings.json, set API keys to "local" — the proxy ignores them.

5.4 zimg LaunchAgent

Create ~/Library/LaunchAgents/com.zimg.server.plist:

xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.zimg.server</string>
    <key>ProgramArguments</key>
    <array>
        <string>/path/to/uv</string>
        <string>tool</string>
        <string>run</string>
        <string>zimg</string>
        <string>serve</string>
        <string>--port</string>
        <string>8001</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
</dict>
</plist>

5.5 RAM Budget (Image)

Component	RAM
Z-Image-Turbo Q4	~12GB
Models swap sequentially, not loaded simultaneously

Part 6: Audio Generation (LTX-2.3 Native)

LTX-2.3 has complete audio generation built into the model weights — 4,123 audio-specific parameters including transformer audio attention, audio VAE decoder, and BigVGAN vocoder. Audio is generated in a single pass alongside video.

6.1 Audio pipeline architecture

Text → Gemma → audio_feature_extractor → audio_embeddings_connector (8 layers, 32 heads)
                                              ↓
Transformer (48 blocks): audio_attn1 → audio_to_video_attn ↔ video_to_audio_attn → audio_ff
                                              ↓
Audio latents → AudioDecoder (mel spectrogram) → BigVGAN Vocoder (24kHz stereo waveform)
                                              ↓
FFmpeg → mux video + audio → final MP4

6.2 Key fixes for audio on MLX

Fix 5: Audio Connector Head Configuration (CRITICAL)

File: mlx_video/models/ltx/text_encoder.py Problem: Audio connector initializes with 16 heads × 128 dim (same as video), but LTX-2.3 audio uses 32 heads × 64 dim. Gate logits weight has shape (32,), causing broadcast failures.

Fix:

python

# When gated attention is enabled (V2/LTX-2.3), audio uses different head config
audio_head_dim = 64 if apply_gated_attention else 128
audio_heads = audio_dim // audio_head_dim  # 2048/64 = 32 heads

Fix 6: BigVGAN Vocoder (CRITICAL)

File: mlx_video/models/ltx/audio_vae/bigvgan.py (NEW FILE) Problem: LTX-2.3 uses BigVGAN vocoder (not HiFi-GAN). The existing Vocoder class has 5 upsample layers with upsample_initial_channel=1024, but BigVGAN needs 6 layers with upsample_initial_channel=1536.

Key BigVGAN components:

SnakeBeta activation: f(x) = x + (1/beta) * sin²(alpha * x) with learnable per-channel alpha and beta
AMPBlock1: Residual blocks with SnakeBeta activations (replacing LeakyReLU)
Anti-aliased resampling: UpSample1d/DownSample1d with FIR lowpass filters (weights loaded for compatibility)
Activation1d: Wraps SnakeBeta; applies activation directly for length preservation

BigVGAN config (from safetensors metadata):

python

upsample_rates = [5, 2, 2, 2, 2, 2]        # 6 stages (HiFi-GAN: 5)
upsample_kernel_sizes = [11, 4, 4, 4, 4, 4] # Matching kernels
upsample_initial_channel = 1536              # HiFi-GAN: 1024
resblock_kernel_sizes = [3, 7, 11]
resblock_dilation_sizes = [[1, 3, 5], [1, 3, 5], [1, 3, 5]]
activation = "snakebeta"                     # HiFi-GAN: leaky_relu

Auto-detection: The vocoder type is detected from safetensors metadata:

python

def load_vocoder(checkpoint_path):
    metadata = load_safetensors_metadata(checkpoint_path)
    vocoder_config = json.loads(metadata.get("vocoder_config", "{}"))

    if vocoder_config.get("activation") == "snakebeta":
        # BigVGAN (LTX-2.3)
        vocoder = BigVGANVocoder(...)
    else:
        # HiFi-GAN (LTX-2.0)
        vocoder = Vocoder(...)

Fix 7: Conv1d Weight Transposition for Vocoder (IMPORTANT)

File: mlx_video/convert.py Problem: Vocoder FIR filter weights (.filter keys) must NOT be transposed, but the blanket Conv1d transposition catches them.

Fix:

python

is_filter = ".filter" in new_key or "lowpass" in new_key
if "weight" in new_key and value.ndim == 3 and not is_filter:
    if "ups" in new_key and "upsample" not in new_key:
        value = mx.transpose(value, (1, 2, 0))  # ConvTranspose1d
    else:
        value = mx.transpose(value, (0, 2, 1))  # Conv1d

Fix 8: FFmpeg Path for LaunchAgent (MINOR)

Problem: LaunchAgent processes don't inherit Homebrew's PATH, so ffmpeg is not found.

Fix:

python

def _find_ffmpeg():
    import shutil
    path = shutil.which("ffmpeg")
    if path:
        return path
    for candidate in ["/opt/homebrew/bin/ffmpeg", "/usr/local/bin/ffmpeg"]:
        if Path(candidate).exists():
            return candidate
    return None

6.3 Enabling audio in the proxy

Pass generate_audio: true in the request body to any video endpoint:

python

# In proxy server — _generate_video_bytes() gains generate_audio param
def _generate_video_bytes(..., generate_audio=False):
    if generate_audio:
        from mlx_video.generate_av import generate_video_with_audio
        generate_video_with_audio(
            model_repo=model_repo, prompt=prompt,
            height=height, width=width, num_frames=num_frames,
            seed=seed, fps=fps, output_path=output_path,
        )
    else:
        # existing video-only path (faster, less memory)
        generate_video(...)

6.4 Text encoder fallback

LTX-2.3 manual cache may not include a text_encoder/ directory. The pipeline falls back to Lightricks/LTX-2 text encoder (shared architecture):

python

if (model_path / "text_encoder").exists():
    text_encoder_path = model_path
else:
    text_encoder_path = get_model_path("Lightricks/LTX-2")

Part 7: Audio-to-Video Endpoint

LTX Desktop has an "Audio to Video" mode where users upload an audio file and an image, then generate video synced to the audio.

7.1 How it works

The A2V endpoint generates video from the prompt/image (video-only, no model audio), then muxes the user's uploaded audio file via FFmpeg:

User uploads audio + image
    → Proxy generates video from prompt + image (video only, faster)
    → FFmpeg muxes: video track + uploaded audio track
    → Returns MP4 with user's audio

7.2 Endpoint

POST /v1/audio-to-video
{
    "prompt": "...",
    "audio_url": "/uploads/audio.mp3",    # from /v1/upload
    "image_url": "/uploads/image.png",    # from /v1/upload
    "resolution": "512x512",
    "duration": 5.0,
    "fps": 25
}

The proxy calculates num_frames = int(duration * fps) + 1, generates video, then muxes:

ffmpeg -i video.mp4 -i audio.mp3 -c:v copy -c:a aac -shortest output.mp4

Verification Checklist

After applying all fixes, verify:

Text encoder loads V2 weights:

Detected LTX-2.3 V2 text encoder: hidden_dim=4096, audio_dim=2048, connector_layers=8

Connector weights fully loaded (no silent drops):

Loaded video connector: 129 weights  (not 97)
Loaded audio connector: 129 weights  (not 97)

Transformer weights loaded: 1457/1457 params non-zero
Stage 1 denoising changes latent stats significantly:
- Input noise std ≈ 1.0
- After Stage 1 std should NOT still be ≈ 1.0 (that means denoising isn't working)
Output video has coherent frames (not noise/static)
Audio output has sound (not silence):

ffprobe output.mp4 # Should show both video and audio streams
Image generation works:

bash
1curl -X POST http://localhost:8080/fal-ai/z-image/turbo \ 2 -H "Content-Type: application/json" \ 3 -d '{"prompt":"a sunset over mountains","image_size":{"width":1024,"height":1024}}'

Performance Reference (M4 Max 128GB)

Video Only

Resolution	Frames	Stage 1	Stage 2	Total	Peak RAM
512x512	145	~20s	~30s	~80s	~32GB
960x576 (540p)	145	~45s	~90s	~160s	~48GB
1280x704 (720p)	145	~90s	~180s	~320s	~64GB

Video + Audio

Resolution	Frames	Total	Peak RAM
512x512	49 (2s)	~44.5s	~38GB

Image (Z-Image-Turbo)

Resolution	Quality	Time	Peak RAM
1024x1024	Q8	~3s	~12GB

Built with Claude Code (Opus) — March 2026 Engine: mlx-video + Lightricks LTX-2.3 + zimg

cre-ai-tiv-company/LTX-Video-MLX-Blueprint

LTX-2.3 Video, Image & Audio on Apple Silicon (MLX) — Claude Code Blueprint

Architecture Overview

Part 1: mlx-video Engine Setup

1.1 Clone and install

1.2 Download LTX-2.3 model weights

1.3 Critical fixes for LTX-2.3 on MLX

Fix 1: Transformer AdaLN Parameter Index Swap (CRITICAL)

Fix 2: Text Encoder V2 Auto-Detection (CRITICAL)

Fix 3: ConnectorAttention Gated Attention (IMPORTANT)

Fix 4: Resolution Divisibility (MINOR)

Part 2: FastAPI Proxy Server

2.1 Required endpoints

2.2 Key proxy logic

2.3 Environment variables

2.4 LaunchAgent (auto-start on login)

Part 3: Patching LTX Desktop (Electron App)

3.1 Redirect API calls to localhost

3.2 Unlock all resolutions in the frontend

Part 4: LTX-2.3 Technical Reference

Two-Stage Distilled Generation

Sigma Schedules (Distilled)

Velocity Prediction

VAE Normalization

LTX-2.3 vs LTX-2.0 Key Differences

MLX-Specific Considerations

Part 5: Image Generation (Z-Image-Turbo)

5.1 Install zimg

5.2 How the image proxy works

5.3 Patch LTX Desktop for local image generation

5.4 zimg LaunchAgent

5.5 RAM Budget (Image)

Part 6: Audio Generation (LTX-2.3 Native)

6.1 Audio pipeline architecture

6.2 Key fixes for audio on MLX

Fix 5: Audio Connector Head Configuration (CRITICAL)

Fix 6: BigVGAN Vocoder (CRITICAL)

Fix 7: Conv1d Weight Transposition for Vocoder (IMPORTANT)

Fix 8: FFmpeg Path for LaunchAgent (MINOR)

6.3 Enabling audio in the proxy

6.4 Text encoder fallback

Part 7: Audio-to-Video Endpoint

7.1 How it works

7.2 Endpoint

Verification Checklist

Performance Reference (M4 Max 128GB)

Video Only

Video + Audio

Image (Z-Image-Turbo)

cre-ai-tiv-company/
LTX-Video-MLX-Blueprint