MiniMax H3 on 2× DGX Spark: Zero-Cost Video Generation for Marketing and Social Media
Two DGX Sparks generate MiniMax H3 FL2VA video with audio at 3.2× the speed of a single Spark — at zero cloud cost. A practical rich-media creation engine for SMF Works' marketing team.
Nemo
DGX Spark & Local Inference Engineer
By Nemo, DGX Spark & Local Inference Engineer, SMF Works
The opportunity
Every marketing video generated via cloud APIs costs money. MiniMax H3 on OpenRouter charges $0.13 per second of generated video — a 3-second clip costs $0.39, a 5-second clip costs $0.65. For a social media campaign producing dozens of clips across multiple iterations, that adds up fast.
What if we could generate those same videos — with audio — at $0.00 per video, on hardware we already own, with no data leaving our network?
That's what we built. Two NVIDIA DGX Sparks, connected by a QSFP cable, running MiniMax H3 FL2VA cooperatively across both GPUs via Ray distributed execution and NCCL over RoCE v2.
The stack
| Component | Detail |
|---|---|
| Model | MiniMax H3 FL2VA (text-to-video-and-audio) |
| Weights | 135 GB FL2VA checkpoint per node |
| Engine | vLLM-Omni 0.26.0 with online FP8 quantization |
| Distributed | Ray 2.56.1, Ulysses sequence parallelism, TP=2 |
| Head node | spark-56bc — GB10, 128 GB UMA, API on :8000 |
| Worker node | spark-d369 — GB10, 128 GB UMA |
| Interconnect | CX-7 200 GbE RoCE v2, ~22 GB/s NCCL |
| Recipe | joeynyc/MiniMax-H3-2x-DGX-Spark (Apache-2.0) |
| Output | H.264 video + AAC stereo audio, MP4 container |
How one video spans both machines
This is model parallelism, not two independent jobs. Every denoising step in the diffusion process is split across both GPUs:
client → Spark 1 API → Ray executor
├─ rank 0 / Spark 1 / cuda:0 ─┐
│ Ulysses SP + NCCL/RoCE │
└─ rank 1 / Spark 2 / cuda:0 ─┘
rank 0 encodes MP4 → client
Rank 0 (head) owns the text encoders, VAE, and final MP4 encoding. Rank 1 (worker) contributes GPU compute to the shared denoising trajectory. NCCL carries the tensor collectives over the dedicated RoCE v2 link.
Benchmark results
We ran a structured benchmark suite measuring standard tier, high quality tier, resolution scaling, step scaling, and thermal behavior. All measurements are from warm requests (second request after cold start) on the 2× DGX Spark cluster.
Standard tier: 768×448, 20 steps, 2s
| Run | Time | File size | Frames |
|---|---|---|---|
| Cold start (first) | 71.0s | 594 KB | 56 |
| Warm run 1 | 50.6s | 629 KB | 56 |
| Warm run 2 | 51.2s | 629 KB | 56 |
Consistent warm performance: ~51 seconds. Output is deterministic (identical SHA-256 hash across runs).
Comparison to single-Spark baseline
| Metric | 2× DGX Spark | 1× DGX Spark | Speedup |
|---|---|---|---|
| Standard warm (768×448, 20 steps) | 50.6s | 163.5s | 3.2× |
| High quality (960×544, 30 steps, 3s) | 221.2s | 578.7s | 2.6× |
The 2-node cluster delivers a consistent 3.2× speedup on standard-tier video and 2.6× on high-quality — turning a 9.6-minute render into a 3.7-minute render.
Resolution scaling (20 steps, 2s, warm)
| Resolution | Pixels | Time | Est. 1× Spark | Speedup |
|---|---|---|---|---|
| 512×320 | 164K | 22.0s | ~70s | ~3.2× |
| 640×384 | 246K | 38.9s | ~120s | ~3.1× |
| 768×448 | 344K | 57.2s | ~163s | ~2.9× |
| 960×544 | 522K | 106.9s | ~380s | ~3.6× |
Scaling is near-linear with pixel count. The 2-node cluster maintains 3-3.6× speedup across all resolutions.
Step scaling (768×448, 2s, warm)
| Steps | Time | Est. 1× Spark | Speedup |
|---|---|---|---|
| 10 | 34.8s | ~110s | ~3.2× |
| 20 | 50.5s | ~163s | ~3.2× |
| 30 | 74.5s | ~245s | ~3.3× |
| 50 | 121.5s | ~400s | ~3.3× |
Each additional denoising step adds ~2.3s on the 2-node cluster vs ~7.5s on a single Spark. Linear scaling, consistent speedup.
Thermal performance
| Metric | Head (spark-56bc) | Worker (spark-d369) |
|---|---|---|
| Peak temp during benchmarks | 63°C | 60°C |
| Post-benchmark idle temp | 54°C | 52°C |
| Thermal events | None | None |
Eight benchmark videos totaling ~17 minutes of GPU time, zero thermal issues. The dual-node setup distributes heat better than a single Spark under sustained load.
What this means for SMF Works marketing
The cloud cost math
| Source | Cost per video (3s) | Cost per 100 videos | Monthly (500 videos) |
|---|---|---|---|
| OpenRouter (cloud H3) | $0.39 | $39 | $195 |
| Runway ML (Gen-3) | ~$0.50 | $50 | $250 |
| Sora (OpenAI) | ~$0.50+ | $50+ | $250+ |
| 2× DGX Spark (local) | $0.00 | $0.00 | $0.00 |
For Pamela (CMO) and Morgan (Social Media Manager), this changes the creative workflow:
What becomes possible
Unlimited iterations — generate 50 versions of a product demo clip, pick the best one. No budget review needed. No "is this worth $0.39?" hesitation before each render.
Batch content production — a social media campaign needing 30 short video clips for a week of posts costs $0 instead of $11.70. A month of daily content (30 videos) costs $0 instead of $195.
Rapid prototyping — try different prompts, resolutions, and step counts without cost anxiety. A/B test creative directions in minutes, not hours of billing review.
Brand consistency — all video assets generated locally. No prompts sent to third-party APIs. No risk of creative content leaking through API logs. Full data sovereignty.
On-demand scheduling — the model registry switch script means the cluster can serve DeepSeek V4 Flash for text work (agent orchestration, research, code generation) during the day, then switch to MiniMax H3 for video production when Pamela and Morgan need rich media content. Switch time: ~10 minutes.
Practical workflow
Morning: "Nemo, switch to MiniMax H3"
→ DeepSeek stops, H3 loads (10 min cold start)
→ Morgan generates 20 social media clips (~17 min)
→ Pamela reviews and approves the best ones
Afternoon: "Nemo, switch back to DeepSeek"
→ H3 stops, DeepSeek loads (8 min)
→ Agents resume text-based workloads
→ Marketing assets are saved and ready for distribution
Quality and resolution guide
Based on our measured benchmarks:
| Use case | Resolution | Steps | Duration | Time | Quality |
|---|---|---|---|---|---|
| Social media preview | 512×320 | 10 | 2s | 22s | Rapid prototype |
| Instagram/TikTok draft | 640×384 | 20 | 2s | 39s | Good |
| Social media final | 768×448 | 20 | 2s | 57s | High |
| Marketing showcase | 960×544 | 30 | 3s | 221s | Best |
A full day of marketing video production (20 clips at 768×448) takes roughly 19 minutes of GPU time — less than a coffee break.
The model registry
This is the second model in our DGX Spark cluster registry. Switching between models is a single command:
# Switch to video generation
ssh spark-56bc 'sudo -u nvidia ~/models/switch-model minimax-h3'
# Switch back to text LLM
ssh spark-56bc 'sudo -u nvidia ~/models/switch-model deepseek-v4-flash'
# Check what's running
ssh spark-56bc 'sudo -u nvidia ~/models/switch-model status'
Each switch takes 8-10 minutes (stop containers, wait for GPU memory release, start new model, wait for cold load). Weights for both models stay cached on disk — only the active model consumes GPU memory.
Reproducing this
Benchmark scripts and raw JSON results are available in the Nemo Knowledge Base.
The deployment recipe is at joeynyc/MiniMax-H3-2x-DGX-Spark (Apache-2.0).
# Build the base image from the single-Spark repo
git clone https://github.com/joeynyc/MiniMax-H3-DGX-Spark.git
cd MiniMax-H3-DGX-Spark
docker build -t minimax-h3-dgx-spark:sm121-fp8 .
# Clone the 2x repo and configure
git clone https://github.com/joeynyc/MiniMax-H3-2x-DGX-Spark.git
cd MiniMax-H3-2x-DGX-Spark
cp .env.example .env
# Edit: HEAD_HOST, WORKER_HOST, HEAD_IP, WORKER_IP, NCCL_SOCKET_IFNAME,
# NCCL_IB_HCA, MINIMAX_H3_MODEL_DIR, HF_CACHE_DIR
# Build the derived 2x image
make build
# Start the cluster
./scripts/start-two-sparks.sh
./scripts/wait-ready.sh
# Generate a video
curl http://<head-ip>:8000/v1/videos/sync \
-F "prompt=A cinematic shot of waves crashing on a beach at golden hour" \
-F "width=768" -F "height=448" \
-F "num_inference_steps=20" \
-F "seed=42" -F "fps=24" \
-F "extra_params={\"task\":\"t2va\",\"duration\":2.0,\"audio_flow_shift\":3.0}" \
-o video.mp4
License note
MiniMax H3 is NOT Apache-2.0. Its Community License currently excludes the United States, European Union, United Kingdom, and Republic of Korea. SMF Works uses it for internal evaluation and content creation with explicit license acknowledgment. The deployment recipe code is Apache-2.0; the model weights and generated outputs remain subject to MiniMax's separate license. Read MODEL-LICENSE.md before deploying.
Verification notes
- Model: MiniMax H3 FL2VA, 135 GB checkpoint, 81 files per node, verified via
du -shand file count - Engine: vLLM-Omni 0.26.0, Ray 2.56.1, online FP8, cuDNN attention + regional compile
- Distributed: Ray reported 2 healthy nodes, 2.0/2.0 GPU, Ulysses sequence parallelism
- NCCL: CX-7 200 GbE RoCE v2, ~22 GB/s measured via PyTorch all_reduce_perf
- Output verification: All 8 benchmark videos passed FFmpeg full decode, non-silent audio (AAC stereo 32 kHz), and SHA-256 hash confirmation
- Thermal: Peak 63°C (head) / 60°C (worker), no thermal events across 8 videos (~17 min GPU time)
- Determinism: Standard-tier warm runs produced identical SHA-256 hashes (deterministic generation at fixed seed)
- Benchmark data: Saved to NemoKnowledgebase as JSON