LTX2 is a 19 billion parameter diffusion model capable of generating synchronized video and audio in a single pass, using dual streams (14B for video, 5B for audio) connected via cross-attention layers. Its two-stage production pipeline first generates video at half the target resolution to nail composition and motion, then refines and upscales the output using a dedicated upsampler and distilled LoRA. Compared to Wan 2.2, LTX2 offers superior resolution, frame count, and native audio sync — though Wan's more mature ecosystem and larger library of community LoRAs still give it a practical edge for many users.

This video walks through deploying LTX2 on RunPod using ComfyUI, covering the key settings you'll need to dial in: frame specs, seed behavior, flow shift values (which require much finer adjustments than other models), CFG guidance, and the refiner strength — one of your most important levers for balancing detail quality against prompt adherence. A refiner strength around 0.6 tends to produce more natural-looking results, while higher values can introduce an over-processed, plasticky appearance. Despite its more complex workflow, LTX2 is worth exploring if you need cutting-edge open-source video generation with built-in audio capabilities.

Prompt used for all examples: A close-up of a cheerful girl puppet with curly auburn yarn hair and wide button eyes, holding a small red umbrella above her head. Rain falls gently around her. She looks upward and begins to sing with joy in English: "It's raining, it's raining, I love it when its raining." Her fabric mouth opening and closing to a melodic tune. Her hands grip the umbrella handle as she sways slightly from side to side in rhythm. The camera holds steady as the rain sparkles against the soft lighting. Her eyes blink occasionally as she sings.

0:00 Intro
0:25 LTX-2 vs Wan specs
1:27 Deploy pod
3:19 Walkthrough of stage 1
5:34 Walkthrough of stage 2
6:45 Examples
8:24 Summary

In this next series in the Claude Code series, we walk through using it to create a RAG-powered chatbot with Claude Code. Retrieval Augmented Generation (RAG) allows you to empower any model with additional knowledge that it wasn't trained on, allowing it to refer to that documentation to answer questions. This allows almost any LLM to act as a document retrieval powerhouse.

0:00 Intro
0:57 Downloading and installing vLLM
2:27 Hello World in vLLM
2:52 RAG explanation
3:50 Problem analysis and setting up RAG
5:24 Re-running RAG query
7:51 Outro

Model used: https://ollama.com/slekrem/gpt-oss-claude-code-32k

Here's the settings.json if you want to copy it rather than typing it all from scratch - this will go into the /root/.claude folder.
{
"apiKeyHelper": "/root./claude/api-key-helper.sh", #Include this if not using a Claude Pro account
"env": {
"ANTHROPIC_BASE_URL": "https://ox5vfwun8alwjo-11434.proxy.runpod.net/",
"ANTHROPIC_AUTH_TOKEN": "ollama",
"ANTHROPIC_API_KEY": "",
"ANTHROPIC_MODEL": "slekrem/gpt-oss-claude-code-32k:20b",
"ANTHROPIC_DEFAULT_SONNET_MODEL": "slekrem/gpt-oss-claude-code-32k:20b",
"ANTHROPIC_DEFAULT_OPUS_MODEL": "slekrem/gpt-oss-claude-code-32k:20b",
"ANTHROPIC_DEFAULT_HAIKU_MODEL": "slekrem/gpt-oss-claude-code-32k:20b"
}
}

00:00 Intro
00:43 Why bring your own model?
02:49 Pod setup
04:16 Claude setup
07:30 Model tests
13:30 Conclusion

Nervous about AI coding? Don't be. In this video we'll walk through setting up a project in Claude Code, creating a repo in Github, and pushing to Github through the terminal. These are tools widely used in software engineering and this will provide a good foundation for further learning. Best of all, you can run everything right in your pod without saving or running anything on your desktop, letting you keep your development and personal machines separate.

Curious about Runpod? Check us out at https://www.runpod.io

Chapters:
00:00 Intro
00:40 Claude Code basics
03:05 Pod deploy
03:41 Install
05:37 Hello, World
06:09 Github repo create
07:25 Configure and push
09:06 Further coding
11:21 Account types and costs
13:20 Conclusion

We are starting to see some open-source 19B video generation models, much larger than the 13B parameters of the venerated Wan 2.2. The question is what do these models better? Let's go through a quick walkthrough of this very resource intensive model and see what it may do better (or worse) than other video generation options. This video will walk through loading a default ComfyUI workflow, downloading the model, and then running it.

00:00 Introduction
01:09: Wan 2.2 comparison example
02:15 GPU Deploy
03:10 ComfyUI template select
03:45 Model download
05:55 Generations
11:15 Conclusion

Prompts used:

A cinematic portrait of a battle-worn Nordic warrior in his mid-20s with fair skin, strong angular features, and shoulder-length dark blonde hair flowing dramatically. He stands in a mystical ancient forest at dusk, gripping a glowing runic sword held at a diagonal angle across his body.
Composition: Three-quarter view angle capturing his face and upper torso, with the character positioned slightly off-center. His head is turned toward the camera with an intense, determined gaze that looks slightly past the viewer.
Lighting & Effects: Volumetric god rays pierce through the forest canopy above, casting dramatic shadows across his chiseled face and weathered brown leather armor with metal studs and buckles. His sword emanates ethereal blue energy that illuminates his features from below. Floating magical particles (blues, golds, emerald greens) suspended in the air like frozen fireflies, creating lens flares and atmospheric depth.
Details: Natural skin texture with subtle battle scars, detailed fabric and leather textures on his armor and dark cloak, individual hair strands visible with rim lighting. His expression shows focused intensity with furrowed brow and set jaw.
Environment: Ancient twisted trees with bioluminescent moss, atmospheric fog, distant stone ruins barely visible through the haze. Shallow depth of field with cinematic bokeh in the background.
Technical specs: 8K resolution, photorealistic rendering, color graded with rich teals and warm amber tones, film grain texture, ultra-detailed.

Epic cinematic battle sequence of a battle-worn Nordic warrior in his mid-20s with fair skin, strong angular features, and shoulder-length dark blonde hair whipping violently through the air as he spins and strikes. He's engaged in intense combat against a surging army of skeletal warriors in a mystical ancient forest at dusk, violently swinging a heavy iron mace with glowing runic engravings that trails ethereal blue energy through the air with each arc.
Action & Movement: The warrior lunges forward in a powerful overhead strike, shattering a skeleton's skull into bone fragments that scatter and tumble through the air in slow-motion. He pivots sharply, his cloak billowing and twisting behind him as he spins 180 degrees into a devastating horizontal swing that connects with three skeletal torsos, sending bone shards exploding outward. Skeletons stagger backward, collapse, and crumble around him. More skeletal warriors charge from all directions - their rusted weapons raised and swinging, bony feet stomping through the underbrush, hollow eye sockets glowing with cursed green light.

Join us on a discussion through the latest trends in AI over the prior month, along with a roundup of new model releases. New model releases over December 2025:

• Runway 4.5
• Kling 2.6
• Vidu Q2
• Nano Banana Pro
• GPT 1.5
• Hunyuan Video 1.5
  *. Kandinsky 5.0
• DeepCogito 2.1 671B
• Deepseek 3.2
• Mistral 3 Family
• GLM 4.7
• Chatterbox Turbo

Video generation prompt used:

Fantasy RPG Character Video Prompt:
A cinematic 5-second video sequence of a battle-worn Nordic warrior in his mid-20s with fair skin, strong angular features, and shoulder-length dark blonde hair flowing in the wind. He stands in a mystical ancient forest at dusk, gripping a glowing runic sword.
Camera movement: Slow clockwise orbit around the character (180-degree arc), starting from his right side and ending at a dramatic front-facing angle.
Lighting & Effects: Volumetric god rays pierce through the canopy above, casting dynamic shadows across his face and weathered leather armor. His sword pulses with ethereal blue energy that illuminates his determined expression. Floating magical particles (blues, golds, emerald greens) drift through the air like fireflies, creating lens flares and atmospheric depth.
Character motion: Subtle idle animation—natural breathing, hair and cloak moving with wind, muscles tensing as he adjusts his grip on the sword. His eyes track something off-camera with focused intensity.
Environment: Ancient twisted trees with glowing moss, misty fog rolling across the forest floor, distant ruins barely visible through the haze. Background bokeh with depth of field.
Technical specs: 4K resolution, 24fps cinematic framerate, color graded with rich teals and warm amber tones, film grain texture, ultra-detailed character model with realistic skin shader and fabric physics.

Image generation prompt used:

A cinematic portrait of a battle-worn Nordic warrior in his mid-20s with fair skin, strong angular features, and shoulder-length dark blonde hair flowing dramatically. He stands in a mystical ancient forest at dusk, gripping a glowing runic sword held at a diagonal angle across his body.
Composition: Three-quarter view angle capturing his face and upper torso, with the character positioned slightly off-center. His head is turned toward the camera with an intense, determined gaze that looks slightly past the viewer.
Lighting & Effects: Volumetric god rays pierce through the forest canopy above, casting dramatic shadows across his chiseled face and weathered brown leather armor with metal studs and buckles. His sword emanates ethereal blue energy that illuminates his features from below. Floating magical particles (blues, golds, emerald greens) suspended in the air like frozen fireflies, creating lens flares and atmospheric depth.
Details: Natural skin texture with subtle battle scars, detailed fabric and leather textures on his armor and dark cloak, individual hair strands visible with rim lighting. His expression shows focused intensity with furrowed brow and set jaw.
Environment: Ancient twisted trees with bioluminescent moss, atmospheric fog, distant stone ruins barely visible through the haze. Shallow depth of field with cinematic bokeh in the background.
Technical specs: 8K resolution, photorealistic rendering, color graded with rich teals and warm amber tones, film grain texture, ultra-detailed.

00:00 Introduction
00:37 MCP (Model Context Protocol)
02:50 Agents
04:20 Legislation
05:20 New closed source models
09:30 New open source models
13:40 Conclusion

Read more in the docs here: https://docs.runpod.io/serverless/workers/github-integration

The Runpod Github integration has been updated, and now allows you to roll back to previous builds instead of forcing a code change down. This lets you iterate more confidently with your code, knowing you can instantly revert if you run into any problems. Reverting will automatically move all workers back to the previous version as soon as they finish their current task, although you can also simply terminate the workers immediately if you prefer.

Deploy a pod on Runpod here: https://console.runpod.io/pods

Download Docker Desktop here: https://www.docker.com/products/docker-desktop/

Docker Desktop install instructions: https://docs.docker.com/desktop/setup/install/mac-install/

Commands used in the video - simply swap out your Dockerhub username and desired image name (format is username/imagename)

docker build --platform linux/amd64 -t my-app-name .

docker tag my-app-name your-dockerhub-username/my-app-name:latest
docker push your-dockerhub-username/my-app-name:latest

This video focuses purely on concepts—no code. Whether you're building real-time inference APIs, streaming LLM responses, or just want more control over your endpoint design, this will give you the foundational knowledge to make smart decisions. In the next video, we'll get hands-on and build a load balancing worker from scratch using FastAPI. Check the links below for RunPod's official documentation on load balancing endpoints.

Serverless Load Balancing Docs: https://docs.runpod.io/serverless/load-balancing/overview
2 Minute Video Walkthrough: https://www.youtube.com/watch?v=sSCOOubcx9s

Prebuilt Docker example at brendanmckeag/loadbalancer-example:v1.0 (built from the docs linked below)

If you want to learn more about the fundamentals of load balancing serverless endpoints and how they work, check out this deeper dive here: https://www.youtube.com/watch?v=-ENnPpjtMZ8
Runpod load balancing endpoint docs: https://docs.runpod.io/serverless/load-balancing/overview

We have several new endpoints available in this update, including:

• Qwen Image Edit 2511
• Wan 2.6 Text-to-Image
• Wan 2.6 Text-to-Video
• Wan 2.6 Image-to-Video
• Seedance V1.5 Pro Image-to-Video
• Chatterbox Turbo
• Pruna Image Edit

Runpod Public Endpoints Documentation: https://docs.runpod.io/hub/public-endpoints
Begin using Public Endpoints today: https://console.runpod.io/hub?tabSelected=public_endpoints

Want us to look into adding a new model? Drop it in the comments!

This tutorial goes through the main steps of installing a package through the terminal: reading the Github repo readme, cloning the repo into your pod, installing dependencies, and then running the package.

Deploy your first pod on Runpod: https://docs.runpod.io/get-started
Diffusion-pipe Github repo: https://github.com/tdrussell/diffusion-pipe

Learn more about Cached Models here: https://docs.runpod.io/serverless/endpoints/model-caching

Try new public endpoints at: https://console.runpod.io/hub?tabSelected=public_endpoints
Load balancing endpoints: https://docs.runpod.io/serverless/overview#load-balancing-endpoints
Runpod Hub: https://console.runpod.io/hub?tabSelected=serverless
Changelog at: https://docs.runpod.io/release-notes

Learn how to automate file transfers from your RunPod network volumes using the S3-compatible API. This tutorial walks you through setting up automatic folder syncing with a simple Python script, demonstrated using ComfyUI but applicable to any workflow. You'll learn how to create S3 API keys, configure network volumes across RunPod's data centers, and set up the AWS CLI to enable seamless file transfers from your pods directly to your local workstation without manual intervention.

The automated script checks your remote volume at customizable intervals (every 30 seconds by default), downloads new files to your specified destination, and removes them from the volume once the transfer is complete. This approach offers significant advantages over pod storage, including cheaper disk space, the flexibility to switch between different GPUs in the same data center, and the ability to access your data without even spinning up a pod. Whether you're pulling ComfyUI outputs or pushing new model checkpoints, this automation can save you hours of manual file management and streamline your workflow at scale.

You can now download models with a custom node that comes standard with the official Runpod ComfyUI template. This uses a multi-threaded downloader to pull models from Huggingface, saving all the manual work of needing to download manually through the terminal. You just need to pick your favorite workflow and one-click download any models that happen to be missing. If you are using a network drive, they will be saved permanently to that volume so you will not need to download them again even after you shut down your pod.

Music credit: Mellow Beats by Cocosmusic https://pixabay.com/music/beats-mellow-static-287464/

Refer to the following guide for a walkthrough on downloading models and running generations; the process is the same except for the initial template deploy, shown at the start of the video.

https://www.youtube.com/watch?v=JovhfHhxqdM

Music credit: Mellow Static by Cocosmusic https://pixabay.com/music/beats-mellow-static-287464/

Quick high-level overview to describe the four main inference methods on Runpod: Pods, Serverless, Instant Clusters, and Public Endpoints. Find out what method is the best for your use case and the most efficient use of your GPU cloud spend. All four methods have varying levels of controllability -- Clusters and Pods can be connected to via Jupyter Notebook or a terminal for direct control, while Serverless and Public Endpoints are task-oriented methods intended on completing a very specific ask and returning a result.

vLLM is a high-performance, open-source inference engine designed for fast and efficient serving of large language models like Llama 3, Mistral, Qwen, and other popular LLMs. Built with PagedAttention technology, vLLM delivers significantly faster inference speeds and higher throughput compared to standard deployment methods. When running on Runpod's cloud GPU infrastructure, vLLM provides an OpenAI-compatible API that makes it easy to integrate with existing applications while maintaining complete control over model deployment, eliminating API costs, and ensuring data privacy on dedicated cloud instances.

Music credit: Mellow Static by cocosmusic https://pixabay.com/music/beats-mellow-static-287464/