MiniMax released H3 on August 2, 2026, calling it a general-purpose omni-modal generative system. Within 48 hours, an MLX port appeared for Apple Silicon. Jeremy Morgan reported on X that the model carries 115GB of weights and produces a 15-second clip in roughly 45 minutes on an M5 Max.
TL;DR: MiniMax-H3 generates 15-second omni-modal video with native audio on Apple Silicon. The full model requires 115GB of weights, but NF4 quantization brings the minimum VRAM requirement down to 7GB, enabling local inference on 16GB Macs. Optimized setups on an M5 Max produce a complete clip in roughly 45 minutes.
What Is H3-metal and How Does It Run MiniMax-H3 on Apple Silicon?
H3-metal is the community-driven effort to bring MiniMax-H3 inference to Apple Silicon using MLX, Apple’s native machine learning framework. Simon Willison noted on August 4, 2026 that PipeNetwork released an MLX port within two days of MiniMax-H3’s launch. The port runs entirely on Mac hardware. No cloud GPU required.
MiniMax-H3 accepts text, images, audio, and video as inputs, then generates synchronized video with native audio. The MLX port packages this into uv one-liners, meaning users can launch inference with a single terminal command. Michael Guo confirmed on X that he ran the FL2VA model variant natively through mlx-serve, not ComfyUI, producing a full 15-second spot with native audio on an M5 Max with 128GB of unified memory.
The project targets developers and creators who want local video generation without renting GPU instances. The code lives in the PipeNetwork/minimax-h3-mlx repository. Configuration options let users select resolution, frame count, and quantization level before generation begins.
The architecture relies on Apple’s Unified Memory Architecture, which shares RAM between the CPU and GPU. This design eliminates the bottleneck of copying weights between separate VRAM pools. MLX handles scheduling across the Neural Engine and GPU cores automatically.
How Much Memory Does MiniMax-H3 Need on Mac?
Memory requirements scale dramatically based on quantization. The full-precision model needs 115GB of weights, as Jeremy Morgan reported on August 4, 2026. That figure effectively limits unquantized inference to Mac Studio or Mac Pro configurations with 192GB of unified memory or more.
NF4 quantization changes the equation entirely. A post from taziku CEO on X (August 4, 2026) confirmed that combining 4-bit NF4 quantization with DiffSynth-Studio’s VRAM management drops the minimum requirement to 7GB of available VRAM. This means a 16GB MacBook Air can load and run the model, leaving roughly 9GB for macOS and other processes.
Michael Guo’s setup on an M5 Max used the 8-bit model variant with 128GB of unified memory. His configuration generated 960×544 resolution video at 362 frames in a single pass. The 8-bit middle ground balances quality against memory pressure for users who have 64GB or more.
| Configuration | Quantization | Minimum VRAM | Recommended Mac | Source |
|---|---|---|---|---|
| Full precision | FP16/BF16 | ~115GB | Mac Studio 192GB | Jeremy Morgan, X |
| 8-bit | INT8 | ~60-70GB | M5 Max 128GB | Michael Guo, X |
| 4-bit | NF4 | ~7GB | Any 16GB Mac | taziku CEO, X |
Memory allocation is dynamic. DiffSynth-Studio loads model layers based on available memory rather than demanding a fixed allocation upfront. If the system detects pressure, it offloads layers to disk. This comes at a speed cost.
What Generation Speeds Can You Expect on M4 and M5 Chips?
Generation speed depends heavily on chip tier, memory bandwidth, and quantization. Jeremy Morgan’s August 4, 2026 post on X reported roughly 45 minutes per 15-second clip on an M5 Max with 128GB. Michael Guo independently confirmed similar timing on the same hardware using the 8-bit FL2VA variant.
Lower-tier chips tell a different story. A Japanese developer writing on note.com (August 4, 2026) tested MiniMax-H3 on a Mac mini with an M4 Pro and 64GB of unified memory. The conclusion was blunt: generation speed is quite slow. The author did not publish exact frame-per-second numbers but indicated that patience is mandatory.
The performance gap between M4 Pro and M5 Max stems from memory bandwidth. The M5 Max delivers approximately 546 GB/s, while the M4 Pro peaks around 273 GB/s. Video diffusion models are memory-bandwidth-bound workloads. More bandwidth means faster weight loading per denoising step.
Ivan Fioravanti noted on X (August 4, 2026) that he was testing the model on Apple Silicon but did not expect super speed. His assessment aligns with every published benchmark so far. Local inference trades speed for privacy and zero per-generation cost.
Frame count directly affects total time. Michael Guo’s 362-frame generation at 960×544 resolution represents roughly 24 frames per second over 15 seconds. Reducing resolution or frame count proportionally cuts generation time, though the relationship is not perfectly linear due to fixed overhead costs.
Which Quantization Formats Work Best for Local Inference?
Three quantization paths dominate the H3-metal ecosystem: full precision (FP16/BF16), 8-bit integer (INT8), and 4-bit NF4. Each format targets a different hardware tier. Choosing correctly determines whether the model runs at all.
NF4 is the format that makes 16GB Macs viable. The taziku CEO post on X (August 4, 2026) specifically credited the combination of NF4 quantization and DiffSynth-Studio’s adaptive VRAM management for enabling 7GB minimum inference. NF4 compresses each weight to 4 bits, reducing the model footprint by approximately 4x compared to FP16. Quality degradation exists but remains acceptable for preview and experimentation.
The 8-bit INT8 path suits users with 64GB to 128GB of unified memory. Michael Guo’s M5 Max setup used the 8-bit FL2VA model through native mlx-serve. His single-pass generation produced a complete 15-second clip with no stitching. The 8-bit format preserves more detail than NF4, particularly in audio quality and temporal consistency.
Full precision remains the reference standard but is impractical for most users. With 115GB of weights, only machines with 192GB configurations can load the model without quantization. The community hardware map published on GitHub (August 8, 2026) recommends full precision exclusively for Mac Studio and Mac Pro systems with maximum memory.
The MiniMax H3 Prompt Enhancer gist by Naxdy provides additional tooling for optimizing prompts before generation. Better prompts reduce wasted cycles on rejected outputs. This matters more when each generation takes 45 minutes.
Key factors when choosing quantization:
- Available unified memory: Check your Mac’s total RAM, then subtract roughly 9GB for macOS overhead
- Target resolution: Higher resolutions like 960×544 benefit from 8-bit or higher to preserve detail
- Audio quality needs: NF4 compresses audio components more aggressively than INT8
- Patience threshold: Lower quantization means faster iteration cycles during prompt tuning
- Storage space: The 115GB full-precision download dwarfs the approximately 30GB NF4 variant
- DiffSynth-Studio compatibility: The adaptive loader supports all three formats but performs best with NF4 on constrained systems
- mlx-serve requirements: Native serving through mlx-serve works with 8-bit and full precision; NF4 requires DiffSynth-Studio’s runtime
- Output format: All formats produce synchronized video and audio; the difference lies in fidelity, not capability
What Tools and Runtimes Power the Apple Silicon Port?
H3-metal relies on MLX, Apple’s open-source machine learning framework designed specifically for Apple Silicon architecture. The runtime executes inference natively through mlx-serve, avoiding abstraction layers that would slow computation. This matters. Jeremy Morgan confirmed on X that the MLX port runs via “uv one-liners,” meaning developers can launch the model with a single command after installing the uv package manager. The 115 GB model weights download directly to local storage, and MLX handles memory mapping against unified memory.
Michael Guo’s optimization work demonstrated that native MLX outperforms ComfyUI wrappers for MiniMax-H3 inference on Apple Silicon. His setup used mlx-serve directly rather than routing through a node-based interface. The result was a complete 15-second video with native audio generated in a single pass. No stitching required.
For entry-level hardware, the toolchain shifts. DiffSynth-Studio provides an alternative runtime that manages VRAM allocation dynamically, loading model components based on available memory rather than demanding the full 115 GB upfront. This approach enables inference on machines with as little as 7 GB of available VRAM, according to a post by taziku CEO 田中義弘. The system pairs 4-bit NF4 quantization with adaptive memory loading to fit constrained environments.
A prompt enhancer tool, shared as a GitHub Gist by user Naxdy, helps users structure text inputs for better generation results. It preprocesses prompts to align with MiniMax-H3’s expected input format.
Can Entry-Level Macs With 16GB Run MiniMax-H3?
Yes, but with significant compromises in speed and output quality. The combination of 4-bit NF4 quantization and DiffSynth-Studio’s memory management allows MiniMax-H3 to load on 16 GB Apple Silicon Macs, requiring a minimum of 7 GB of available VRAM. This was confirmed by Japanese developer 田中義弘, who documented the approach on X.
The trade-offs are substantial. At 4-bit quantization, the model loses fine detail in generated video, and motion coherence degrades compared to higher precision modes. Generation times on entry-level hardware have not been formally benchmarked in the available sources, but given that an M5 Max with 128 GB takes roughly 45 minutes per clip at 8-bit precision, 16 GB machines will take considerably longer.
Memory pressure is the primary concern. macOS itself consumes 4–6 GB of unified memory during normal operation, leaving roughly 10–12 GB for model inference on a 16 GB system. DiffSynth-Studio addresses this by loading only the model components that fit within available memory, swapping layers as needed during generation. The system works, but it was not designed for production-speed workflows.
For anyone testing MiniMax-H3 on entry-level hardware, expectations should be calibrated accordingly. The capability exists. The experience will test your patience.
What Are the Limitations of Running H3 Locally?
The most immediate limitation is generation speed. Jeremy Morgan reported approximately 45 minutes to produce a single 15-second video clip on an M5 Max with 128 GB of unified memory. That hardware represents the current high end of Apple’s laptop lineup. Lower-tier machines will be slower.
Memory footprint is the second constraint. The full-precision model weighs 115 GB, which exceeds the unified memory of every shipping Mac except the Mac Studio and Mac Pro configurations with 192 GB or 256 GB. Quantization reduces this requirement, but each step down in precision introduces quality degradation that affects temporal consistency and fine visual detail.
| Configuration | Precision | Memory Required | Practical Output |
|---|---|---|---|
| Full precision | 16-bit | ~115 GB | Highest quality |
| 8-bit quantized | INT8 | ~60 GB | Near-original quality |
| 4-bit NF4 | NF4 | ~30 GB | Noticeable detail loss |
| DiffSynth adaptive | 4-bit | 7 GB minimum | Significant degradation |
Resolution and frame count are also limited by local hardware. Michael Guo’s optimized configuration produced 960×544 resolution video at 362 frames — a modest resolution by cloud API standards. Higher resolutions would demand more memory and computation time, pushing beyond what current Apple Silicon can handle in a single generation pass.
Rough edges remain. Morgan noted that the MLX port documents its limitations honestly, meaning users should expect incomplete features and potential crashes during longer generation runs.
How Does Local Inference Compare to MiniMax’s Cloud API?
MiniMax’s cloud API generates 15-second video clips in approximately 60 seconds, based on the company’s published performance benchmarks. Local inference on an M5 Max takes 45 minutes for equivalent output — roughly 45 times slower. The gap is enormous.
However, local inference offers advantages that the cloud API cannot match. Generation is completely private, with no data leaving the machine. There are no per-generation costs, no rate limits, and no dependency on server availability. Users can modify the model, adjust quantization parameters, and experiment with architecture-level changes that cloud APIs do not expose.
| Factor | Cloud API | Local (M5 Max, 128 GB) |
|---|---|---|
| Time per 15s clip | ~60 seconds | ~45 minutes |
| Cost per generation | Pay per use | Free after hardware |
| Privacy | Server-side processing | Fully offline |
| Customization | Fixed parameters | Full model access |
| Resolution options | Multiple presets | Hardware-limited |
| Audio generation | Included | Included |
Quality differences depend heavily on quantization level. At 8-bit precision, Michael Guo reported output quality approaching cloud API results, with native audio included in a single generation pass. At 4-bit NF4 on entry-level hardware, quality drops noticeably, with reduced temporal coherence and fine detail loss.
The cloud API also handles concurrent requests and scales automatically. Local inference processes one generation at a time. For production workflows requiring rapid iteration, the cloud API remains the practical choice. For developers studying the model, testing modifications, or generating content with strict privacy requirements, local inference fills a different niche entirely.
What Hardware Configurations Deliver the Best Results?
The M5 Max with 128 GB of unified memory represents the best-documented configuration for local MiniMax-H3 inference. Michael Guo successfully generated a complete 15-second video at 960×544 resolution with 362 frames and native audio in a single pass using 8-bit quantization. His setup used native MLX through mlx-serve, avoiding ComfyUI overhead.
The Mac mini with an M4 Pro chip and 64 GB of unified memory provides a functional but slower alternative. Japanese developer LUCK JOH tested this configuration and confirmed that generation works, though speeds are “quite slow” compared to higher-end chips. The M4 Pro’s memory bandwidth of 273 GB/s is less than half of the M5 Max’s, directly impacting inference speed since transformer models are memory-bandwidth-bound.
For optimal local performance, several factors matter:
- Unified memory capacity: 128 GB or more allows 8-bit quantization without aggressive memory management
- Memory bandwidth: Higher bandwidth directly reduces generation time for transformer architectures
- Storage speed: NVMe SSDs with 7,000 MB/s read speeds minimize model loading time for the 115 GB weight files
- Cooling sustained performance: Mac Studio and desktop form factors maintain peak clock speeds longer than laptops
- Precision selection: 8-bit offers the best quality-to-performance ratio for capable hardware
- Runtime choice: Native MLX via
mlx-serveoutperforms ComfyUI wrappers - Resolution tuning: 960×544 at 362 frames is a proven working configuration
- Background processes: Closing memory-hungry applications frees unified memory for inference
Entry-level Macs with 16 GB can technically run the model through DiffSynth-Studio with 4-bit NF4 quantization, but the experience is far from optimal. The minimum 7 GB VRAM requirement leaves almost no headroom, and generation times will extend well beyond the 45-minute baseline observed on M5 Max hardware.
Frequently Asked Questions
Can MiniMax-H3 run on a Mac with only 16GB of unified memory?
Yes. Combining 4-bit NF4 quantization with DiffSynth-Studio’s adaptive VRAM management enables MiniMax-H3 to load on 16 GB Apple Silicon Macs, requiring a minimum of 7 GB of available VRAM. The model loads components dynamically based on available memory rather than demanding the full 115 GB weight file upfront, as documented by Japanese developer 田中義弘 on X.
How long does it take to generate a 15-second video on an M5 Max?
Approximately 45 minutes per clip. Jeremy Morgan reported this timing on an M5 Max with 128 GB of unified memory using the MLX port with standard settings. Michael Guo achieved a complete 15-second generation with native audio in a single pass on the same hardware class using 8-bit quantization at 960×544 resolution.
What quantization level should I choose for MiniMax-H3 on Apple Silicon?
For Macs with 128 GB or more unified memory, 8-bit quantization provides the best balance of quality and performance, as demonstrated by Michael Guo’s successful single-pass generation. For machines with 16 GB, 4-bit NF4 quantization is required to fit within memory constraints, accepting noticeable degradation in fine detail and temporal coherence.
Does H3-metal require ComfyUI or can it run standalone?
H3-metal runs standalone through native MLX using mlx-serve, which Michael Guo confirmed outperforms ComfyUI wrappers for MiniMax-H3 inference. Jeremy Morgan also noted that the MLX port launches via uv one-liners, requiring no node-based interface. ComfyUI integration exists as an option but is not necessary for local generation.
Summary
- Native MLX inference works: MiniMax-H3 generates 15-second video with audio on Apple Silicon without cloud GPU servers, using
mlx-serveand 115 GB of model weights. - M5 Max with 128 GB is the sweet spot: Michael Guo’s configuration produced complete clips in a single pass at 8-bit precision, taking roughly 45 minutes per generation.
- Entry-level hardware is supported: 16 GB Macs can run the model through DiffSynth-Studio with 4-bit NF4 quantization, requiring only 7 GB of VRAM minimum.
- Local inference trades speed for privacy and control: Cloud API generates clips in ~60 seconds versus 45 minutes locally, but local runs are free, private, and fully customizable.
- The toolchain is maturing fast: From MLX ports to prompt enhancers and adaptive memory management, the ecosystem around local MiniMax-H3 inference is expanding rapidly.
If you are experimenting with MiniMax-H3 on Apple Silicon, share your benchmarks and configurations. The community documentation is growing, and real-world results help everyone calibrate expectations.